nyuuzyou/wikis huggingface dataset:
Scratch

Scratch is a visual programming language created in 2003 by a collaboration between MIT Media Lab's Lifelong Kindergarten Group (LLK) and UCLA, led by Mitchel Resnick and Yasmin Kafai, for teaching children how to program.
==External resources==
* Scratch at MIT
* Scratch Wiki
* wikipedia:Scratch (programming language)
Category:Languages
Category:Non-textual
Category:High-level
Category:Implemented
Category:Turing complete
Category:2003
Scratch is dumb

Scratch is dumb is a trivial brainfuck substitution made by User:None1, it is made to response to the person who invented the esolang Esolang Simply Created To Annoy People Who Dislike Scratch, who wants to annoy people who dislike scratch. This esolang will tell you that Scratch IS useless and even dumb! Even dumber than brainfuck! Because Scratch has no ASCII table and no control characters (That means you cannot say mutiline text in Scratch)
==Introduction==
This is a brainfuck-equivalent esolang, instead of brainfuck's command, you use the unprintable characters 0x00 to 0x07, that means all Scratch is dumb programs are binaries.
==Why this esolang tells you that Scratch is dumb==
Because this esolang uses unprintable characters which you cannot type and print in Scratch, but a proper language like brainfuck can print it easily.
==Convert to brainfuck==
Here is a Scratch is dumb to brainfuck table.
Scratch is dumb (hex) brainfuck
00 +
01 -
02 ,
03 .
04 <
05 >
06 [
07 ]
==Example Programs==
The programs here are in hex dump.
===Cat Program===
 00 06 02 03 07
===Hello World===
00 00 00 00 00 00 00 00 06 05 
00 00 00 00 06 05 00 00 05 00 
00 00 05 00 00 00 05 00 04 04 
04 04 01 07 05 00 05 00 05 01 
05 05 00 06 04 07 04 01 07 05 
05 03 05 01 01 01 03 00 00 00 
00 00 00 00 03 03 00 00 00 03 
05 05 03 04 01 03 04 03 00 00 
00 03 01 01 01 01 01 01 03 01 
01 01 01 01 01 01 01 03 05 05 
00 03 05 00 00 03 
===brainfuck Interpreter===
Because dbfi is not public domain, this program is moved here.
==Turing completeness==
Scratch is dumb programs are binaries but it is still Turing complete because brainfuck is.
P.S.: I dislike Scratch very much, I think Scratch isn't even capable of being an esolang (nor is it capable of being a non-esoteric programming language)!
==Interpreter==
===Python===
import sys
def run(code):
 s1=[]
 s2=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j==6:
 s1.append(i)
 if j==7:
 m=s1.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]==0:
 tape[p]=(tape[p]+1)%256
 if code[cp]==1:
 tape[p]=(tape[p]-1)%256
 if code[cp]==2:
 tape[p]=ord(sys.stdin.read(1))%256
 if code[cp]==3:
 print(chr(tape[p]),end=)
 if code[cp]==4:
 p-=1
 if code[cp]==5:
 p+=1
 if code[cp]==6:
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==7:
 if tape[p]:
 cp=matches[cp]
 cp+=1
with open(sys.argv[1],'rb') as f:
 run(f.read())
===Scratch===
* https://scratch.mit.edu/projects/963563769
Category:Languages
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:2023
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Binary
Category:Implemented
Scratcholang

Scratcholang is an esoteric programming language created by User:PikaboyPlaysGames that you are officially able to use in Scratch. You can use it here.
==Language Overview==
Scratcholang is inspired by brainfuck and uses some of it's. Scratcholang has 7 cells of 1025 bits signed. Scratcholang has 20 commands.
 
Symbol 	Description 	Notes
+ 	Adds number in the selected cell by one 	N/A
- 	Subtracts number in the selected cell by one 	N/A
> 	Moves to the next cell 	Moves to the first cell if the selected cell is the last one
< 	Moves to the previous cell 	Moves to the last cell if the selected cell is the first one
1 	Outputs the cell as a number 	N/A
A 	Outputs the cell as a letter in the english alphabet 	Going too high will output the space ( ) instead
= 	Outputs the cell as a symbol 	In outputting the cell to be a symbol, each symbol will be selected from these in numerical order ~ ` ! @ # $ % ^ & * ( ) _ - + = { [ } ] : ; " ' I \ < , > . ? / Going too high will also output space
/ 	Sets the number in the cell back to 0 	N/A
, 	Adds the number in the selected cell by the cell after it 	Will do nothing if it's the seventh cell
. 	Subtracts the number in the selected cell by the cell after it 	Will do nothing if it's the seventh cell
; 	Same as , but it'll add to the number before it 	Will do nothing if it's the first cell
: 	Same as . but it'll subtract to the number before it 	Will do nothing if it's the first cell
# 	Acts like some sort of checkpoint for @ or $ 	N/A
@ 	Repeats everything that was done after the last # once 	N/A
$ 	Same as the @ symbol but does it indefinitely 	N/A
* 	Waits for an input from the user before continuing 	Must be a number
["code"]	Checks if the latest input from the user is higher than the number in the selected cell, if true then the code inside the cell will run.	Can only be used once
("code")	Checks if the latest input from the user is lesser than the number in the selected cell, if true then the code inside the cell will run.	Can only be used once
{"code"}	Checks if the latest input from the user is equal to the number in the selected cell, if true then the code inside the cell will run. 	Can only be used once
==Examples==
===HELLO WORLD!===
++++,,>A<+A>,,>----AA+++A>A<<,>++++A----A<.>A+++A<++++A<-A-=
===Truth Machine===
+*{#1$}/1
===XKCD Random Number===
++++1
==See also==
*brainfuck
*Scratch
==External Resources==
Scratcholang Project/Interpreter
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Linear bounded automata
Category:2023
Screwtape

Screwtape is an esoteric programming language designed as a format for a tape reader. The tape reader, or virtual machine, is in one of several states as its head moves over the tape.
== Virtual Machine Description ==
So the virtual machine has a tape, full of 2^16 bytes, which stores both the code and data. 
Registers are: acc - an accumulator, head - tape head, which is usually incremented.
There's also an array tracks of pointers to various addresses in the tape. Currently incomplete, much subject to change
=== States ===
State	Description
Exec 	Reads bytes from the tape as instructions
Outpn	Outputs bytes from the tape until reaching a null byte, upon which state switches to exec
Outpd	Outputs bytes from the tape while decrementing acc, until acc is equal to 0
Inp 	Reads characters from inp to the tape while decrementing acc, until acc is equal to 0
=== Instructions === 
These are executed when the state is exec
Instruction	Description
k 	kill execution
o 	go to output mode*
i 	go to input mode
t 	Sets the location of the track with number of acc to pointed by the next two bytes in little endian
p 	Plays the track with ID of acc
s 	Set accumulator
Category:Languages
Category:Cell-based
Category:Self-modifying
Category:Languages
Category:2016
ScripTur

ScripTur An esoteric programming language based off of turing machine theory, written by Davy Wybiral in 2007.
==Description==
There are actually two parts of ScripTur that are important, the scripts which build the turing machines, and the input that becomes the tape of the turing machine. ScripTur takes a script file and builds a virtual turing machine from it, it then reads the command line argument as input for the intitial tape state. It's been said that any computable problem can be expressed on a turing machine.
==Syntax==
The script files have a very basic syntax. Each line of the script represents a state that the turing machine can be in (yes, you will need a text editor with numbered lines). On each line (in each state) the machine may have any number of conditions. Conditions are enclosed in parentheses and are laid out in this order...
(in, out, move, jumpToLine)
The turing machine will read the character at the character pointer (which starts at the first character in the input), if that character is equal to the "in" value, then it gets changed to the "out" value, the character pointer gets adjusted by the value of "move" (-1 moves to the left of the current character, 1 moves to the right), and then the machine jumps to the line designated by "jumpToLine".
If a line has more than one condition, it starts by checking the condition on the far left, if that one is false, then it moves to the next, and so on. The machine will end when a condition's "jumpToLine" value is 0 (the terminate command) or when there is no true condition for that line. To repeat a line, just make its "jumpToLine" equal to its own line. To leave a character unchanged, change it to itself. The input tape is infinite, you may go as far left as you'ld like, and as far right as you'ld like.
==Examples==
Hello world (no input):
 (0,72,1,2)
 (0,101,1,3)
 (0,108,1,4)
 (0,108,1,5)
 (0,111,1,6)
 (0,32,1,7)
 (0,119,1,8)
 (0,111,1,9)
 (0,114,1,10)
 (0,108,1,11)
 (0,100,1,12)
 (0,33,1,0)
Binary Incrementer (input in the form of a binary number):
 (48,48, 1,1) (49,49,1,1) (0, 0,-1,2)
 (49,48,-1,2) (48,49,0,0) (0,49, 0,0)
Adding Machine (input in the form of INTEGER+INTEGER):
 (48,48,1,1)(49,49,1,1)(50,50,1,1)(51,51,1,1)(52,52,1,1)(53,53,1,1)(54,54,1,1)(55,55,1,1)(56,56,1,1)(57,57,1,1)(43,43,1,1)(0,0,-1,2) 
 (48,57,-1,2)(57,56,-1,3)(56,55,-1,3)(55,54,-1,3)(54,53,-1,3)(53,52,-1,3)(52,51,-1,3)(51,50,-1,3)(50,49,-1,3)(49,48,-1,3)(43,0,1,5)
 (43,43,-1,4)(48,48,-1,3)(49,49,-1,3)(50,50,-1,3)(51,51,-1,3)(52,52,-1,3)(53,53,-1,3)(54,54,-1,3)(55,55,-1,3)(56,56,-1,3)(57,57,-1,3)
 (57,48,-1,4)(48,49,0,1)(49,50,0,1)(50,51,0,1)(51,52,0,1)(52,53,0,1)(53,54,0,1)(54,55,0,1)(55,56,0,1)(56,57,0,1)
 (57,0,1,5)
==External resources==
*ScripTur download home (source and linux binary)
ScriptJava

== Description ==
ScriptJava is like JavaScript, but different. It reverses the behavior when possible.
https://github.com/epic-pigeon/scriptjava
== Substitutions ==
"string" <-> "gnirts"
generator function <-> simple function
async function <-> sync function
callee(arg0, other...) <-> arg0(callee, other...)
new callee(arg0, other...) <-> new arg0(callee, other...)
(Does nothing if there are no arguments)
reverses statements in every block scope
if (cond) { then... } else { otherwise... } <-> if (cond) { otherwise... } else { then... }
cond ? then : otherwise <-> cond ? otherwise : then
a operator b <-> b operator a
a.b <-> b.a
a[b] <-> b[a]
for (a1; a2; a3) {...} <-> for (a3; a2; a1) {...}
for (a1 of a2) {...} <-> for (a2 of a1) {...}
for (a1 in a2) {...} <-> for (a2 in a1) {...}
true, false <-> false, true
{ key1: value1, ... } <-> { value1: key1, ... }
== Examples ==
=== Hello, world! ===
"!dlrow ,olleH"(log.console)
=== Fibonacci numbers ===
async function* fib(n) {
 return (1 - n)(fib) + (2 - n)(fib);
 if (1 === n) {} else return 1;
 if (0 === n) {} else return 0;
}
let i = 0;
for (i++; 20 < i;) (i(fib))(log.console)
Category:Languages Category:Implemented Category:High-level
Scroll

Scroll is an esolang created by User:WreckingGames. it was made for no reason.
it uses a string for data.
== Commands ==
Command	Action
[ 	Remove the last value of the string and add it to n. If the last value of the string is the last value of n, skip to the matching ].
] 	Goto the matching [ if the last value of the string isn't the last value of n, else remove the last value of n.
$ 	Put the last value of the string at the start of the string.
* 	Discard the last value of the string.
Everything else adds itself to the string.
When the program ends, the string is printed.
== Examples ==
=== Hello, world ===
Hello, World!
=== Quine ===
q
due to not being able to add any of the commands to the string, you are not able to create a quine that uses actual commands.
=== Truth-machine ===
(input)0[1]
=== Increment binary value ===
!(binary value)0[*0$]*1![$]*
== External resources ==
Python interpreter by MathR: https://github.com/theMathR/Scroll
Category:2021Category:Output onlyCategory:LanguagesCategory:Implemented
Scrum

SCRUM is designed for being a language which is understandable for business as well as for developers and losely inspired by the Scrum (software development) framework (hence the name of course). 
The language was created and designed by MityJohn.
== Hello World ==
A glance of the scrum programming language using the 'Hello World' example:
 USER STORY "HelloWorld"
 #REVIEW Our first Scrum Program
 SAY "Hello world!"
 END OF STORY
== Syntax ==
=== File formatting ===
Scrum programs are UTF-8 files with the .scrum file extension.
=== Programming Structure ===
SCRUM code is a structure based upon EPIC's containing multiple USER STORIES or for simple coding purposes on single/multiple USER STORIES. An EPIC can be interpreted as a single class, whereas User stories can be seen as single functions. These User Stories are individual blocks of code logic which can be executed individually. Multiple stories within an epic will fulfil a bigger goal all together.
EPICS and USER STORIES have a name, defined between quotes (without spaces). These epics can be called afterwards (without the spaces).
 EPIC "nameOfTheEpic"
 USER STORY "nameOfTheUS"
 ... code logic ... 
 END OF USER STORY 
 END OF EPIC
All code blocks (e.g. EPIC, USER STORY but also IF or ITERATIONS) are always closed by an END STATEMENT (combinining the initial parent). So for an "EPIC" block, this will be closed by "END OF EPIC".
Initialising a new EPIC and calling an EPICs User Story:
 SampleStoriesEpic IS NEW nameOfTheEpic
 SampleStoriesEpic::nameOfTheUS USING []
=== Operators & Variables declaration ===
All operators are written uppercase for easy readability (as user stories are written in a comprehensive way, we must make a distinction).
===== Plain types =====
Assigning a variable: variable name IS expression
!-
helloWorldText IS "Hello World!"
firstNumber IS 1
-!
===== Array =====
BACKLOG = { , , ... } example_backlog = { 1, 2, "three"} empty_backlog = {}
==== Operators ====
 Operators
Operator 	Value 	Precedence	Example
Assignment 	```IS``` 	1 	```a = 5```
Append value to array 	```ADDING```	1 	```array ADDING "value"```
Logical OR 	```OR``` 	2 	```true OR false```
Logical AND 	```AND``` 	3 	```true AND true```
Left side 	```(``` 	4 	
Right side 	```)``` 	4 	
Equals 	```=``` 	5 	```a = 5```
Not Equals 	```!=``` 	5 	```a != 5```
Greater Than Or Equals	```>=``` 	5 	```a >= 5```
Greater Than 	```>``` 	5 	```a > 5```
Less Than Or Equals 	```<=``` 	5 	```a <= 5```
Less Than 	```<``` 	5 	```a < 5```
Addition 	```+``` 	6 	```a + 5```
Subtraction 	```-``` 	6 	```a - 5```
Multiplication 	```*``` 	7 	```a * 5```
Division 	```/``` 	7 	```a / 5```
Floor Division 	```//``` 	7 	```a // 5```
Modulo 	```%``` 	7 	```a % 5```
NOT 	```!``` 	8 	```!false```
EPIC Instance 	```NEW``` 	8 	```a IS NEW epicName [ 5 ]```
EPIC Property 	```::``` 	8 	```epicName :: storyName```
== References ==
Scrum Home Page
Github Repository
Category:Languages Category:Thematic Category:Pseudonatural Category:Implemented
Sculptlang

`this language is user:guy fawkes reps dream.
== commands ==
 left <
 right >
 middle +
 left and right -
 super left []
 super right .
 super right and left ,
a filled in always goes inbetween commands.
== ascii loop ==
== origins ==
user:guy fawkes rep posted "a language based on sculpting" in the language ideas page. it shortly got deleted due to "not a good suggestion"...
so of course, becaue THIS IS ESOLANGS and NO SUGGESTION IS BAD, i decided to make a language based on that idea. i added it to the gigantic shitpile that is brainfuck derivatives, and posted it to esolangs. (without this section ofc)
Category:LanguagesCategory:2024Category:Two-dimensional languagesCategory:Non-textualCategory:ThematicCategory:Brainfuck derivativesCategory:Brainfuck equivalentsCategory:Turing complete
Sd

=== How it works ===
There are two variables, known as variable1 and variable2. You change these to manipulate code, output ASCII characters and change your position in the code. Your code fails if it reads something which isn't a command.
=== Commands ===
Command	Result
+ 	Add 1 to variable1.
- 	Take 1 from variable1.
* 	Add 1 to variable2.
/ 	Take 1 from variable2.
. 	Replace the command in the position equal to variable2 with the ASCII character equal to the value of variable1.
, 	Replace the command in the position equal to variable1 with the ASCII character equal to the value of variable2.
: 	Set variable1 to user input.
; 	Set variable2 to user input.
! 	Prints all code before the last read location marker.
@ 	Marks location for ! command
=== Basic Examples ===
==== Hello World ====
+++++++++++++@+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*.+++++++++++++++++++++++++++++*.+++++++*.*.+++*.-------------------------------------------------------------------*.------------*.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*.--------*.+++*.------*.--------*.------------------------------------------------------*.!
=== Resources ===
Python Interpreter
Category:Languages
Category:Implemented
Category:2017
Category:Self-modifying
Category:Total
Category:Unusable for programming
Sdac2

sdac2 is a possible stack-based language.
sdac2 has 6 operators: +-/.,* and the two lists. + and-operators work differently in different lists. In the first list, the + and-operators are used to control the addition or subtraction of the current pointer to the value, while in the second list, + Pointer to value added to the list Pointer to value.-Copies the current value to the list without changing the pointer(the pointer in list 1 not be new value).
The / operator is used to switch to another list. 
The . operator is used to output the current pointing value.
The * operator is used to loop through the code before the value of 0.
The , operator is used as input in the first list (similar to BF,) and to clear the current value in the second list.
This is written in sdac2 for the Leonardo Pisano number of the procedure:
 +/+/+/+/+/-+-+-+-+-+(and more...)
==Interpreter==
there is an interpreter:interpreter by python
Category:Languages Category:Stack-based Category:Implemented
You can also copy there (code may be bad):
 stack1 = [0];pointer1 = 0;stack2 = [0];pointer2 = 0;now = 1
 def inte(c,r=1):
 global stack1,pointer1,stack2,pointer2,now
 repeat = 0
 if r:
 now = 1
 stack1 = [0]
 pointer1 = 0
 stack2 = [0]
 pointer2 = 0
 if c.count('*') % 2 > 0:
 print('err:there should be a "*"')
 return 1
 for j,i in enumerate(c):
 if now == 1:
 if i == '+':
 stack1[pointer1] += 1
 elif i == '-':
 stack1[pointer1] -= 1
 elif i == '.':
 print(chr(stack1[pointer1])) 
 elif i == ',':
 stack1[pointer1] = ord(input()[0])
 elif i == '/':
 now = 2
 elif i == '*':
 repeat += 1
 if repeat % 2 == 1:
 while eval(f'stack{now}[pointer{now}]') != 0:
 inte(c[j + 1:][:c[j + 1:].index('*')],0) 
 elif now == 2:
 if i == '+' and len(stack1) > 0:
 stack2[pointer2] += stack1[pointer1]
 if len(stack1) > 1:
 stack1.pop(pointer1)
 pointer1 = 0
 else:
 stack1[0] = 0
 pointer1 = 0
 elif i == '-':
 pointer1 = 0
 stack1.insert(0,stack2[pointer2])
 pointer1 = 1 if len(stack1) > 1 else 0
 elif i == '.':
 print(chr(stack2[pointer2]))
 elif i == '/':
 now = 1
 elif i == '*':
 repeat += 1
 if repeat % 2 == 1:
 while eval(f'stack{now}[pointer{now}]') != 0:
 inte(c[j + 1:][:c[j + 1:].index('*')],0)
 elif i == ',':
 stack2[pointer2] = 0
 return 0 
 inte('+/+/+/+/+/-+-+-+-+-+-+-+-+.')#fib number
 inte('+/+--+--+--+--+--+--,/+/+-+/,*-/./*')#repeat
 inte('+*.')#error
 inte('run your code there')
The effect of the interpreter may not be as good as you think.
==Turing Complete==
I don't know that now. :(
Thank those who help others.
SdofgOS

SdofgOS contains SdofgOS Deleter as a component of the operating system.
== Instructions in the shell ==
=== Deleting a folder ===
An example of deleting the folder dhgjifh is:
djgidyjtrt6t5656556766578jghhhu9xczxcvbdfgh78yrtyt8utlets' se sdofgOS thus dhgjifh
The general syntax for deletion is:
djgidyjtrt6t5656556766578jghhhu9xczxcvbdfgh78yrtyt8utlets' <flags> <Name of computer> <user name> <folder>
== See also ==
SdofgOS Deleter
Category:2020
Category:Stubs
SdofgOS Deleter

SdofgOS Deleter is an esoteric programming language inspired by nothing created by User:LyricLy in 2020.
==Concepts==
SdofgOS Deleter has only one concept: deleting a folder without deleting any of the files in it.
==Instructions==
SdofgOS Deleter has a multitude of instructions:
djgidyjtrt6t5656556766578jghhhu9xczxcvbdfgh78yrtyt8utlets' se sdofgOS thus dhgjifh	Delete a folder without deleting anything inside it.
==Examples==
The following code deletes a folder without deleting anything inside it:
djgidyjtrt6t5656556766578jghhhu9xczxcvbdfgh78yrtyt8utlets' se sdofgOS thus dhgjifh
==Interpreters==
None yet exist.
==Trivia==
SdofgOS Deleter is likely not Turing-complete, as it has no instructions except djgidyjtrt6t5656556766578jghhhu9xczxcvbdfgh78yrtyt8utlets' se sdofgOS thus dhgjifh, which deletes a folder without deleting anything inside it.
==See also==
* SdofgOS
Category:Joke languages
Category:2020
Category:Languages
Category:Total
Category:Unusable for programming
Category:Unimplemented
SeMo-PATH

SeMo-PATH, is derivation of PATH, that is a two-dimensional language inspired by Brainfuck and Befunge. Unlike PATH's environment, SeMo-PATH's consists of a 2D plane of memory cells all initialized to zero, on which is also written the program itself, and character-based standard input and output. PATH understands the following commands:
Command	Explanation
$ 	Start the program here, heading right.
# 	End the program.
+ 	Increment the current memory cell.
- 	Decrement the current memory cell.
} 	Move to the memory cell rightwards.
{ 	Move to the memory cell leftwards.
V 	Move to the memory cell downwards.
A 	Move to the memory cell upwards.
, 	Input an ASCII character from standard input into the current memory cell.
. 	Output an ASCII character from the current memory cell into standard output.
/ 	
If heading in direction:
:right, turn up
:down, turn left
:left, turn down
:up, turn right
\ 	
If heading in direction:
:right, turn down
:down, turn right
:left, turn up
:up, turn left
^ 	If the value of the current memory cell is not 0, turn up.
< 	If the value of the current memory cell is not 0, turn left.
> 	If the value of the current memory cell is not 0, turn right.
v 	If the value of the current memory cell is not 0, turn down.
! 	Jump over the next symbol.
As in Brainfuck, any character not understood as a command is simply skipped over.
==Computational Class==
As any PATH program is also a SeMo-PATH program, and PATH is Turing complete, so SeMo-PATH is Turing also complete.
Category: Languages
Category: Turing complete
Category: Cell-based
Category: Two-dimensional languages
Category: Self-modifying
Sea

Sea is a three command simple translation of Underload. Sea was discovered by Orby during October of 2020.
== Commands ==
Sea consists of three commands: (, ), and &. ( and ) are quoting operators as in Underload. & is the sole sufficient concatenative combinator.
=== Rewrite rules ===
Expression 	Rewritten
(a) & 	(K) (S') a
(b) (a) K 	a
(d) (c) (b) (a) S'	((d) c) a (d) b
Note that only (, ), and & are Sea commands. K and S' are presented as conceptual aids.
== Theory ==
Notice we can reconstruct S' from (, ), and &
 ()()()()()()()&()&&
 ()()()()()()(K)(S')(K)(S')&
 ()()()()()()(K)(S')(K)(K)(S')S'
 ()()()()()()(K)((S')K)S'(S')K
 ()()()()(())(S')K()K(S')K
 ()()()()S'()K(S')K
 (())()()K(S')K
 (())(S')K
 S'
Once we have S' we can recover K?
== See also ==
* The Theory of Concatenative Combinators
Category:Languages Category:2020