nyuuzyou/wikis huggingface dataset:
LOLA

LOLA (Lots Of Lambda Abstractions) is a minimalistic functional programming language devised by User:Smjg. It is based on lambda-calculus.
LOLA is purely functional both in the usual sense (functions do not have side effects) and in the sense David Madore has used to describe Unlambda (functions are the only objects).
A LOLA program consists of a number of function definitions, each of which is a single line of code. Functions are created by writing lambda abstractions in a notation based on de Bruijn indexes. Functions can also be applied to other functions to create new functions. There are no built-in functions in LOLA.
Execution consists of evaluating the main function and then applying it to the Church integers 0 and 1 to determine an input or output event and a new expression on which the process is repeated. LOLA's I/O model uses Church integers to represent character codes.
== Code example ==
The "Hello, world!" program can be written in LOLA as follows:
 comments are anything between space and EOL
 
 +\\\cb,ba,, actually the increment function, so that 6+, adds 6 to its argument
 *\\\cba,, multiplication of Church integers is function composition
 :\\\a\c,c, cons function
 
 this function has no name, so it is the main function
 (the order of function definitions is immaterial)
 :H,:e,:l,:l,:o,:',:_,:w,:o,:r,:l,:d,:!,:%,:\\b,\\a,,,,,,,,,,,,,,,
 
 define the various Church integers in terms of each other
 H*6,^,
 e+d,
 l8+,d,
 o3+,l,
 '_+,^,
 w8+,o,
 r+^,+,e,
 d2%,
 _52,
 !+_,
 
 2\\bba,,
 3+2,
 422,
 5+4,
 6*2,3,
 832,
 %*2,5,
 ^*2,6,
== Computational class ==
LOLA provides the full power of lambda-calculus, which is known to be a Turing complete system. Consequently, LOLA is Turing complete.
== External link ==
* The LOLA Programming Language
Category:Languages
Category:Functional paradigm
Category:Turing complete
Category:Turing tarpits
Category:2006
Category:Implemented
LOLScript

LOLScript is a joke programming language created by User:RyanDolan123 in 2013. It is based off of the Lua scripting language and is similar to LOLCODE, though with more recent memes and such. 
== Keywords ==
Keyword 	Standard Lua Counterpart
IF LE 	if
DEN 	then
PLZ 	do
MAH 	local
LOLK 	end
INDIS 	in
YA 	true
NOP 	false
NOTHING 	nil
IS 	==
ISNT 	~=
LOL 	print
THREAD.XXXX 	coroutine.XXXX
NAWT 	not
LESS 	<
MOAR 	>
LETIME 	os.clock
AND 	and
OR 	or
PCALL 	pcall
UNTIL 	until
SOMETHING 	function
PLZ 	do
FER 	for
INDIS 	in
OR ELSE... 	else
OR ELSE IFDIS	elseif
GET OUT 	return
THREAD 	coroutine
INFINITY 	math.huge
LE PAIRS 	pairs
SHUD BE 	=
LOL WHILE 	while
BREAK ME KK 	break
== Examples ==
Hello World in LOLScript:
 LOL "Hello World!"
99 bottles of beer in LOLScript:
 FER I = 99, 0, -1 PLZ
 IF LE I IS 0 DEN
 LOL "No more bottles of beer on the wall."
 GET OUT
 OR ELSE...
 LOL I.." bottles of beer on the wall."
 LOL I.." bottles of beer."
 LOL "Take one down, pass it around,"
 LOLK
 LOLK
Truth-machine in LOLScript:
 MAH ENTERED SHUD BE NOP
 LOL WHILE YA PLZ
 IF LE NOT ENTERED DEN
 LOL "Input 1 or 0"
 LOLK
 MAH K SHUD BE io.read()
 IF LE K ISNT 0 AND LE K ISNT 1 DEN
 LOL "Y U NO PRINT 1 OR 0"
 ENTERED SHUD BE YA
 OR ELSE IF LE K IS 0 DEN
 LOL "0"
 BREAK ME PLZ
 OR ELSE IF LE K IS 1 DEN
 LOL WHILE YA PLZ
 LOL "1"
 LOLK
 LOLK
 LOLK
Category:Joke languages
Category:Languages
LOLZ

LOLZ is a language that ignores everything except the letters 'l', 'o,' and 'z'. Its main goal is to let users write any program in one line. It is an error-free language, therefore it does not have any run-time or syntax errors. It was written by Cevat Barış Yılmaz.
== Sample Codes ==
Hello World!
lozozlooozlllzlzloozlzlollzlzlollzlzlllozllozlzlollolzlllozlzlooollzlollzlzllzlllolz
Fibonacci Sequence
ozozlozloozlzloololzzozlozloololzzozozlzlzllzozloololozzlollzllollzozlooloozzozllzlzozllzlzllzlozozlzllzlozozlozllzllzozozlzlzllzozloololzzzlozozllzlozlozozloolllzz
==External resources==
* Github Repository
Category:Languages
Category:Implemented
LPL

LPL is a Lightwieght Programming Language
There is only 4 commands:
 /
 >
 <
 “text”
How could we program with only 4 commands?
 “/“ reads out memory commands
 “>” goes to the right memory command
 “<“ goes to the left memory command
 “text” use variable text
What are memory commands?
1. if 13.
2. =
3. ≠
4. <
5. >
6. loop infinite times
7. loop ? times
8. increment to variable ?
9. deincrement to variable ?
10. print(text/var)
11. add ? 14.
12. end loop/if
13. then
14. to ? (could be text)
15. loop back to 1.
Code:
if 0≠1 then
add 1 to True
end
print(True)
/ 0 >>>/ 1 <<<<</
<<<<</ True
>>>>/
<</ True
LRIP

LRIP is a stack-based esolang created by user:Lebster
= Commands =
Command	Explanation
L 	Bitshift top of stack to the left
R 	Bitshift top of stack to the right
I 	Increment top of stack by 1
P 	Print top of stack as ASCII
+ 	Push 0 to top of stack
- 	Pop from top of stack
k 	Push user input ASCII code to top of stack
( 	Start loop
) 	End loop
= Examples =
== Hello world ==
 ILLLILLLP+ILILLLILLIP+ILILLILILLPP+ILILLILILILIP+ILLLLLP+ILILILLILILIP+ILILLILILILIP+ILILILLLILP+ILILLILILLP+ILILLLILLP
== Alphabet ==
 ILLLLLLIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIPIP
= Implementations =
== Python Interpreter ==
import sys
if len(sys.argv) != 2: print('Please input a file name')
else:
	filename = sys.argv[1].lstrip()
	with open(filename, 'r') as file: program = list(file.read().replace('\n', ).lower())
	stack = [0]
	pos = -1
	while pos < len(program) - 1:
		pos += 1;
		char = program[pos]
		if char == 'l': stack[0] = stack[0] << 1
		elif char == 'r': stack[0] = stack[0] >> 1
		elif char == 'i': stack[0] += 1
		elif char == 'p': print(chr(stack[0]), end=)
		elif char == '+': stack.insert(0, 0)
		elif char == '-':
			stack.pop(0)
			if not stack: stack=[0]
		elif char == 'k': stack.insert(0, ord(input('? ')))
		elif char == '(':
			if stack[0] == 0:
				opened = 0;
				pos += 1
				while pos < len(program):
					if program[pos] == ')' and opened == 0: break
					elif program[pos] == '(': opened += 1
					elif program[pos] == ')': opened -= 1
					pos += 1
		elif char == ')':
			if stack[0] != 0:
				closed = 0;
				pos -= 1
				while pos >= 0:
					if program[pos] =='(' and closed == 0: break
					elif program[pos] == ')': closed += 1
					elif program[pos] == '(': closed -= 1
					pos -= 1
=== Usage ===
 LRIP.py <file name>
=== Online ===
Try it online!
Category:Implemented
Category:Languages
Category:Stack-based
Category:2020
Category:Low-level
LRL

LRL (Lazy Reversible Language) is a reversible progrmming language invented by User:ChuckEsoteric08.
==Commands==
Commands	Opreation
INC(x) 	increment register x
DEC(x) 	decrement register x
GOTO(x) 	goto 0-indexed command x. That line should start with (y) where y is line where GOTO command was(counting starts at 1). You can't jump to the same line the GOTO command was. There cannot be multiple GOTO commands which jump to the same line
==Computational class==
Unknown but If GOTO(x) was conditional command(goto if register is zero) it would be Turing-complete becasue
 DEC(r)
 GOTO(z)
can simulate Minsky machine instruction JZDEC(r,z)
Category:Languages Category:Reversible computing Category:Unknown computational class
LSCEF

LSCEF (Lebster's Standard Character Encoding Format) is a method of storing character data created by User:Lebster. Its purpose was to provide an alternative to ASCII for EsoLang creators.
= Encoding =
LSCEF	Character
0 	NEW LINE
1 	SPACE
2 	A
3 	B
4 	C
5 	D
6 	E
7 	F
8 	G
9 	H
10 	I
11 	J
12 	K
13 	L
14 	M
15 	N
16 	O
17 	P
18 	Q
19 	R
20 	S
21 	T
22 	U
23 	V
24 	W
25 	X
26 	Y
27 	Z
28 	a
29 	b
30 	c
31 	d
32 	e
33 	f
34 	g
35 	h
36 	i
37 	j
38 	k
39 	l
40 	m
41 	n
42 	o
43 	p
44 	q
45 	r
46 	s
47 	t
48 	u
49 	v
50 	w
51 	x
52 	y
53 	z
54 	0
55 	1
56 	2
57 	3
58 	4
59 	5
60 	6
61 	7
62 	8
63 	9
64 	!
65 	"
66 	£
67 	$
68 	%
69 	^
70 	&
71 	*
72 	(
73 	)
74 	{
75 	}
76 	[
77 	]
78 	-
79 	=
80 	_
81 	+
82 	;
83 	'
84 	#
85 	~
86 	@
87 	:
88 	,
89 	.
90 	/
91 	?
92 	>
93 	<
94 	\
95 	
96 	`
97 	TAB (\t)
= Usage in interpreters =
Javascript:
 const toLSCEF=(c=>"\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t".indexOf(c))
 const fromLSCEF=(c=>"\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t"[c])
 
 toLSCEF("<") // Returns 93
 fromLSCEF(93) // Returns "<"
Python:
 toLSCEF=lambda c:"\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t".find(c)
 fromLSCEF=lambda c:"\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t"[c]
 
 toLSCEF("A") # Returns 2
 fromLSCEF(2) # Returns 'A'
SWI-Prolog:
 lscef(C, N) :- nth0(N, Chars, C), string_chars("\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t", Chars).
 
 Query:
 lscef(X, 12).
 lscef('\t', Y).
 % results in X = 'K', Y = 97
Chez Scheme:
 (define (toLSCEF n) (string-ref "\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t" n))
 (define (index v l) (cdr (assq v (map cons l (enumerate l)))))
 (define (fromLSCEF c) (index c (string->list "\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t")))
 
 (pretty-print (toLSCEF 0)) ; Returns \#newline
 (pretty-print (fromLSCEF #\h)) ; Returns 35
Wikipedia:C (programming language):
 #define LSCEF_STR "\n ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"£$%^&*(){}[]-=_+;'#~@:,./?><\\|`\t"
 #define LSCEF_STR_LEN 98
 
 int toLSCEF(char c);
 char fromLSCEF(int n);
 
 int toLSCEF(char c)
 {
 int i;
 for(i = 0; i < LSCEF_STR_LEN; ++i)
 if(c == LSCEF_STR[i])
 return i;
 return -1;
 }
 
 char fromLSCEF(int n)
 {
 if(n < LSCEF_STR_LEN)
 return LSCEF_STR[n];
 else
 return (char)-1;
 }
If you are able to write functions for other languages please add them here!
==See also==
* ASCII
* Unicode
Category:Concepts
LZ∞

LZ∞ is an esolang (lazily) invented by User:Pro465 in 2023, based on LZ77 and Xeroxer. in fact, it is also an OISC like Xeroxer.
it is basically a re-encoding of a superset of Echo Tag to make it look like LZ77 compression, or a turing-complete extension of LZ77, depending on the way you look at it. (i was wrong, though it can still possibly be turing complete. see disc)
== Instruction ==
it has only one instruction, which is as follows:
 copy idx, len | (copy the instructions from 
 ip - idx..ip - idx + len (exclusive) 
 to the end of the program, and goto 
 next instruction (ip + 1))
idx is a signed integer, while len is unsigned.
if the current command requires copying from addresses beyond the program, it is a nop. if there are no more instructions to execute, the program halts.
== Python Intepreter ==
prog=[]
ip=0
while len(prog) > ip:
 (idx, len_) = prog[ip]
 if ip - idx >= 0 and ip - idx + len_ <= len(prog):
 prog+=prog[ip-idx:ip-idx+len_]
 ip+=1
simpler interpreter, by User:LyricLy:
for ip, (offset, l) in enumerate(prog):
 start = ip - offset
 end = start + l 
 if 0 <= start < end < len(prog):
 prog += prog[start:end]
== See also ==
* Echo Tag
* Xeroxer
Category:2023
Category:No IO
Category:Unknown computational class
Category:Languages
Category:Implemented
Category:OISC
Category:Self-modifying
LabelLang

LabelLang is multiple subsets of different esolangs which has "GOTO" commands that goes to the specific line. In this subsets "Goto line" are replaced with "Goto label" ones.
==List of languages which has that subset==
*TLIJMMWTRAMCBICHWTPITCSIBCTII using which Bitwise Cyclic Tag interpreter was created in it.
*EsoBASIC which was used as intermediate step in compiling Szewczyk notation for Minsky machine to EsoBASIC.
Category:Esoteric subset
Labra

Labra is an esoteric programming language created by User:DoggyDogWhirl. 
"Labra" stands for "LAzy BRAckets", as it uses lazy evaluation and uses only brackets () [] {} <> as symbols.
==Overview==
As previously mentioned, the only symbols used are ()[]{}<>.
This means that Labra code may look similar to code in Brain-Flak or BracketsLang.
Like those languages, all brackets in Labra code must be matched.
Unlike them, Labra uses the newline \n to separate sections of code.
Also, Brain-Flak is stack-based, BracketsLang is cell-based, and Labra is neither.
(I think it's declarative. I don't know.)
Labra uses two data types, integers and lists. 
Lists may be infinite, and may contain other lists. 
Labra uses 0-indexing.
Input and output are a list of numbers.
ASCII is not used; "23" as input gives 23, and outputting 23 shows "23".
Labra prints out the result of the last line, and the results of any OUTPUTs it finds along the way.
In Labra, a set of brackets may have a result inside and/or a result to its left, or neither.
The arguments a set of brackets has determines its function.
 Functions
Arguments 	( ) 	[ ] 	{ } 	< >
Niladic_() 	ONEReturns 1.() → 1 	ZEROReturns 0.[] → 0 	ARGUMENTInput, or argument into function.{} → input 	PREVIOUSThe result of the previous line.()<> → 1
Monadic_(X)	SUMSum of X.(1,2) → 3 	INDICESThe list of numbers up to X or the length of X.[3,5,0] → 0, 1, 2 	REPEATThe infinite list of only Xs.{1} → 1, 1, 1, 1, ... 	CALLThe result of line X.()<0> → 1
AppliedA() 	ADD ONEAdds/appends 1.2() → 3 	ENCLOSEPuts A in a list.5[] → 5, 	OUTPUTPrints A.1{} → 1 	INVERT-A. If list, swaps indexes and items.4,2<> → ?, ?, 1, ?, 0
DyadicA(X) 	ADDAdds/appends X.2(3,1) → 2, 3, 1	INDUCTIONThe infinite list of X solved repeatedly. {} is initially set to A.1[{}()] → 1, 1+1, (1+1)+1, ...	MAPSolves X for every element of A.{} is set to elements of A.2,3,4{{}()} → 2+1, 3+1, 4+1	INDEXGets the Xth element of A.5,5,1<2> → 1
==Examples==
===2===
Outputs 2.
 ()()
===Cat program===
 {}
===Truth-machine===
 {}
 {{}}
 <{}>
===Hello, world!===
Prints the ASCII values.
 [][{}()()()()()()()()()()()()] 0,12,24,...
 <[]><()()()()()()> H
 <[]><()()()()()()()()>()()()()() e
 <>()()()()()()(){} ll #The l OUTPUTted is the one printed first
 <>()()() o
 <[]><()()()>()()()()()()()() ,
 <[]><()()>()()()()()()()()
 <()()()()>()()()()()()()() w
 <()()()()> o
 <()()()()>()()() r
 <[]><()()()()()()()()()>()()() l
 <[]><()()()()()()()>()()()()() d
 <()()()()()()>() !
 <[<()><()>]{{}()}>
Anything that isn't a bracket or newline is a comment.
===Fibonacci sequence===
 ()[]()[{}<()>[](({}))]{{}<[]>}
 ()[]() 1,1
 [
 {}<()>[] 1,
 (({})) 1,(1+1)
 ] [1,1],[1,2],[2,3],...
 {{}<[]>} 1, 1, 2, ...
==Implementation==
I made a Haskell implementation, but it can't OUTPUT. It can be found here.
I tried to make Python implementation using iterators, but it activates every OUTPUT, can't CALL, and is buggy in general.
At this rate I might have to learn a new language to actually implement it in...
Category:Languages
Category:Declarative paradigm
Category:2021
Category:Unimplemented
Laconic

Laconic is a programming language that compiles to a one-tape two-symbol Turing machine. The goal for its creation was to create two-symbol Turing machines with very few states (a golfed Turing machine) that does something interesting when started on a blank tape. Laconic is a strongly-typed language that supports recursive functions.
== See also ==
* Not-Quite-Laconic
== External resources ==
* Adam Yedidia, Scott Aaronson; "A Relatively Small Turing Machine Whose Behavior Is Independent of Set Theory" (2016), pre-print of the article defining Laconic.
* Scott Aaronson, "The 8000th Busy Beaver number eludes ZF set theory: new paper by Adam Yedidia and me" (2016-05-03), blog post, Shtetl-Optimized.
Category:Implemented
Category:Turing complete
Category:Languages
Category:2016
Laddermaker

Ever wanted to climb a ladder?
With laddermaker you can achieve your dreams.
First we must create a step
 +--+
which represents our very beginning.
Next we need structural support
 + +
which represents the resetting of your value.
Then comes a number (between 1-99)
 +65+
which gives it a value.
After that, we give a nice grip to our step
 ++++
which stores our value to memory.
Why not reset our ladder's value?
 + +
Then we can add more value to our ladder.
 +10+
Let's give our ladder a boost.
 +[]+
Now our ladder has added our value to memory.
We need to reset our ladder's value once more.
 + +
And now we can add a firm base
 +__+
to print our ASCII value stored in memory.
For good measure, let's reset our memory.
 +<>+
Now you have a pretty little K.
 +--+
 + +
 +65+
 ++++
 + +
 +10+
 +[]+
 + +
 +__+
 +<>+
Thanks ladder!
Page inspired by Newton.
==See also==
* staircasemaker
==Interpreter==
* Common Lisp implementation of the laddermaker programming language.
Category:Languages
Category:Joke languages
Category:2021
Category:Implemented
Lag

Lag(Language is good) is an OISC by User:ChuckEsoteric08. it is Similar to Subleq but with variables instead of array.
==Command==
 a;b;c;d
Declare label a, decrement integer c(can be negative) from variable b(result is stored in variable b) and if result is equal to zero go to label d(if result was less than zero then don't). You can reference variable by putting it inside twi "%"s, making possible to go to label scecified by variable.
==Examples==
===Infinity loop===
 test;a;0;test
===Incrementing infinitly===
 loop;a;-1;loop
 go;b;0;loop
==Computational class==
See Lag Turing-completness proof
==External resources==
*Compiler in Batch 
Category:Languages Category:OISC Category:No IO Category:Implemented Category:Turing complete
Lag Turing-completness proof

Here is how you can translate Brainfuck program to Lag.
==TCPL==
It has 4 commands:
 inc;x;
increment variable x
 dec;x;
decrement variable x
 start;x;y;
Start loop x until y will be zero
 end;x;y;
End loop x
==Translating BF to TCPL==
Commands > and < are not implemented, you need to switch variables you use.
Equaletent of + and - are inc;x and dec;x.
 [...]
are:
 start;loop;x;y;
 ...
 end;loop;x;y;
==TCPL to Lag==
Translator can be found in Github repository
Category:Proofs
Lakshayati

Lakshayati is an esoteric programming language created in 2020 with only three operations. Its only data type is strings, and the language relies heavily on executing strings as code. Its name derives from the Sanskrit word लक्षय् meaning "to define".
== Language overview ==
Lakshayati has three operations:
* assigning string values to variables
* concatenating strings
* executing strings as code
If a line begins with a variable, it assigns said variable to the value to the right.
ex: Assigns string "hello world" to variable
 variable "hello world"
To display a string to the screen, assign said string to the variable / (or alternatively ／)
ex: Displays "hello world" to the screen
 / "hello world"
In Lakshayati, if a line begins with a string OR only contains a variable, it will execute the string (or string contained in the variable) as code. All variables are global and mutable; they can be assigned and reassigned in the body of any executed string.
ex: Executes the string "variable 'hello world'", which assigns "hello world" to variable, and then prints "hello world"
 new_variable "variable 'hello world'"
 new_variable
 / variable
Lakshayati variables can use any Unicode characters that aren't quotes or white-space. It also accepts quotes from different languages to form strings. As such, Lakshayati can be typed on nearly any keyboard, regardless of language or writing system. More specific information can be found here.
== Turing completeness ==
Lakshayati is Turing complete. A proof of this can be shown through a Lakshayati implementation of Smallfuck (with infinite memory), which can be found here.
== Example programs ==
Prime or Composite
Quine (program that prints itself)
 line_1 '''single_quote "'"'''
 line_2 """double_quote '"'"""
 line_3 "
 / 'line_1 ' single_quote single_quote single_quote line_1 single_quote single_quote single_quote '
 line_2 ' double_quote double_quote double_quote line_2 double_quote double_quote double_quote '
 line_3 ' double_quote line_3 double_quote '
 ' '
 ' '
 ' line_1 '
 ' line_2 '
 ' line_3"
 
 
 single_quote "'"
 double_quote '"'
 
 / 'line_1 ' single_quote single_quote single_quote line_1 single_quote single_quote single_quote '
 line_2 ' double_quote double_quote double_quote line_2 double_quote double_quote double_quote '
 line_3 ' double_quote line_3 double_quote '
 ' '
 ' '
 ' line_1 '
 ' line_2 '
 ' line_3
== External resources ==
GitHub page for Lakshayati
Online interpreter for Lakshayati
Category:Languages
Category:2020
Category:Implemented
Category:Output only
Category:Turing complete
Lalala

lalala is a minimal esolang based created by User:Yayimhere. it has only 2 commands and a single special argument
== memory ==
memory is stored in a string. this string can only be anything derivable from this BNF:
 <string>::= λ|P|(<string>)|<string><string>|i
the strings starts with a λi in it. also it starts indexing at 2 not 0
== syntax ==
 syntax
command 	description
[x][n][z]	if the symbol following the symbol at index n is x, execute code z. x a empty string
[n:x] 	set symbol at index n to x. x can be a empty string
the special argument for n is ; which is the length of the string. the program loops until the string becomes empty
== computational class ==
lalala is Turing-complete because it can simulate a Bitwise Cyclic Tag with a datastring of 1 (and any BCT program can be simplified to one with a datastring of only 1) like this:
 1 is i
 0 is P
the commands
 BCT: lalala:
 0 <-> [3:]
 10 <-> [2][i][[;:P]]
 11 <-> [2][i][[;:i]]
Category:Languages Category:Turing complete Category:String-rewriting paradigm Category:No IO Category:Turing tarpits Category:Low-level
Lamb

Lamb is a interpreted language made by User:Phase that revolves around Lambda Calculus.
Variables are made by putting the variable name, a : , and a value
 hello:"Hello World"
Functions are written in Lambda Calculus notation
 square:λx.x*x
 
 add:λx.λy.x+y
Lamb is translated in JavaScript code through a Java ScriptEngine, meaning we can put JS code within our Lamb code
 power:λx.λy.Math.pow(x,y)
To use a function, you can call it variables or other arguments
 two:2
 add(two,3);
You can also assign the return of a function to a variable
 h:2
 h:add(h,h)
=== Hello World ===
Returned values are printed out, so all we have to do is return the string "Hello World"
 "Hello World"
== External Resources ==
* The current interpreter
Category:Languages Category:Implemented Category:Turing complete Category:Functional paradigm