ROOP

ROOP (Real Object-Oriented Paradigm) is a two-dimensional language created by User:-Dark-Phantom- on December, 2015. The language uses a rectangular grid of objects represented as characters in the source code. Some objects are static and others can move.
== Grid ==
In each slot of the grid can be only one object, or be empty.
The width of the grid is determined by the line of code with more characters. Lines with fewer characters are filled with empty spaces on the right.
The grid is implicitly surrounded by blocks (#). The following code:
 2A3
 
becomes:
 #####
 #2A3#
 # #
 #####
Note: The above example had no spaces under the characters, there was just one newline character after 3. This creates a line of empty spaces.
== Objects ==
The objects are divided into a few categories: Data, Operators, Pipes, Block. In turn, the operators are divided between Normal Operators and Special Operators.
=== Data ===
Objects of this type can contain one of the following four types of data: signed integer, string, input, output. They also have a direction of movement: left or right (starting to the right). And they also have gravity, so if there is a space below, will fall.
Their position is updated in phase two of each update.
They can be empty or not empty. It is considered an empty object to an integer equal to zero and a string without characters. Are considered non-empty objects nonzero integers, strings with at least one character, input and output.
=== Normal Operators ===
Operators run on the phase one of each update.
Operators get several objects from up, left or right and create a new object with the result. Some operate separately on each axis (grab an object above and put the result below, take an object on the left and put the result on the right).
Except some special cases, operators have two versions. In uppercase mark the objects to disappear for the next update. In lowercase do not.
If the operator attempts to use objects with wrong types or the result could not be delivered, then the operation is considered failed and objects are left unchanged.
The created objects can be placed in an empty space or in a pipe.
In the table below you can see every normal operator with the kind of object that needs at each place and a description of what it does. Those who say mixed means that they can be numbers or strings. Those who say "any" means that it can be any type of data.
Character	Objects that are needed 	Description
A 	up, left, right = number 	Add the numbers. It can operate with only two of the three numbers.
A 	up, left, right = mixed 	Concatenate the strings. The numbers are converted into strings. It can operate with only two of the three strings.
S 	up, left, right = number 	Subtract the numbers. It can operate with only two of the three numbers.
S 	up, left, right = mixed 	Removes all occurrences of the strings in the first string. The numbers are converted into strings. It can operate with only two of the three strings.
M 	up, left, right = number 	Multiply the numbers. It can operate with only two of the three numbers.
M 	up, left, right = mixed 	Repeats the string. Need only one string and one or two numbers.
D 	up, left, right = number 	Divide the numbers. It can operate with only two of the three numbers. If the divisor is zero, the operation is not performed.
D 	up, left = string 	Finds the first occurrence of the string on the left in the string above. Cut the first part of the string and put it under. Cut the second part and puts it on the right. The string on the left is not in any of the two results. If the string to search is empty or can not be found then the first result has all the string of above and the second is empty.
D 	up = stringleft = number 	Cut the string at the specified position. Put the first part of the string below. Put the second part on the right. If the number is negative, it is calculated from the end of the string. If it is greater than the size of the string then the first result has all the string of above and the second is empty.
R 	up, left, right = number 	Divide numbers and calculates the remainder. It can operate with only two of the three numbers. If the divisor is zero, the operation is not performed.
R 	up, left, right = string 	Replaces all the occurrences of the string on the left in the string of above by the string of the right. The numbers are converted into strings.
F 	up, left = number 	Calculates the greatest common divisor between two numbers.
F 	up, left = mixed 	Find the first occurrence of the string on the left in the string of above, puts the index below. If a string is empty or can not be found, the result is -1. The numbers are converted into strings.
P 	Separate axesfirst = number 	If there is a prime number puts a one, else puts a zero.
P 	Separate axesfirst = string 	Calculates the length of the string.
Z 	Separate axesfirst = number 	Reverse the number. The leading zeros are not part of the number.
Z 	Separate axesfirst = string 	Reverse the string.
N 	Separate axesfirst = any 	If there is a empty object puts a one, else puts a zero.
E 	up, left, right = any 	If the objects are equal puts a one, else puts a zero. It can operate with only two of the three objects.
G 	up, left, right = number 	If the number of above is greater than the left which in turn is greater than the right puts a one, else puts a zero. It can operate with only two of the three numbers.
G 	up, left, right = mixed 	If the string of above is greater than the left which in turn is greater than the right puts a one, else puts a zero. They are compared lexicographically. The numbers are converted into strings. It can operate with only two of the three strings.
K 	Separate axesfirst = number 	Creates a random number. The range used depends on the number received. If greater than zero [0, n), if less than zero (n, 0], if zero (minimum, maximum).
K 	Separate axesfirst = string 	Creates a string with a single character, chosen at random from the string received. If empty creates an empty string.
Y 	Separate axesfirst = number 	Convert number to string.
Y 	Separate axesfirst = string 	Convert string to number. If it is unable to convert, the operator fails.
Y 	Separate axesfirst = input 	Creates a output object.
Y 	Separate axesfirst = output 	Creates a input object.
L 	Separate axesfirst = number 	Calculates the absolute value.
L 	Separate axesfirst = string 	Converts letters to lowercase.
U 	Separate axesfirst = number 	If the number is greater than zero returns 1, if it is less than zero returns -1, and if it is zero returns zero.
U 	Separate axesfirst = string 	Converts letters to uppercase.
C 	up, left, right = any 	Reverses the direction of the object that is above and the object that is on the sides pointing to this operator. It works with any number of objects, no need all three.
c 	Separate axesfirst, second = any	Swap the objects.
W 	up = input 	Get string from Input above. Put the object below. If there is an output object below, send it to the screen.
W 	up = mixed 	If there is an output object below, send it to the screen.
w 	up = input 	Get number from Input above. Put the object below. If there is an output object below, send it to the screen.
w 	up = mixed 	If there is an output object below, send it to the screen.
=== Special Operators ===
Special operators work like normal operators but also can receive objects from the pipes.
Character	Objects that are needed 	Description
V 	up = any 	Get object from above (or pipe), put object below.
X 	up, left, right, down = any	Erase objects of the four sides. The lowercase x is not an operator but a pipe.
T 	up = any 	If it receives a non-empty object, puts the number of the current tick below.
H 	up = any 	If it receives a non-empty object, the program ends after phase one of the upgrade.
h 	up = any 	If it receives a non-empty object, the program ends after phase one of the upgrade. Prints all the numbers and strings that remain.
=== Pipes ===
The pipes are objects in which data objects can travel. The whole trip is made in the same update, sending objects up to a special operator. If the object can not be delivered, then the operator that put the object in the pipe fails.
Creating an infinite loop is undefined behavior. The interpreter is not required to detect it and can stay in an infinite loop or produce a stack overflow.
The direction in which the objects move depends on the pipe and operator rather than the direction in which the objects points. Objects created under an operator will go down. Objects created on the right will go to the right.
Character	Name 	Description
- 	Horizontal pipe	Objects that come from the right will go to the left, the others will go to the right.
| 	Vertical pipe 	Objects that come from below will go upwards, the others will go to down.
+ 	Intersection 	The objects continue in the direction they go.
* 	Bouncer 	The objects go in the opposite direction in which they arrive.
> 	Turn right 	The objects rotate 90 degrees to the right (ie clockwise).
< 	Turn left 	The objects rotate 90 degrees to the left (ie counterclockwise).
% 	Duplicator 	Duplicates the object and sends one 90 degrees to the left and the other 90 degrees to the right. The second waits for the first to complete the trip before traveling. The operator fails if both objects can not be delivered.
! 	Teleporter 	Search in the direction of the object another teleporter. If found, the object gets there keeping its direction.
x 	Eraser 	Delete the object. It never fails.
=== Block ===
It is the # character. It does nothing.
== Updates ==
Each update is divided into two phases. After the two, the current tick is increased by one.
=== Phase one ===
Operators are updated one by one, starting at the top left, line by line. Objects created by the operators do not appear in the grid until the phase is not over. The objects can only be created in areas that are now empty and that no other operator used in this phase.
The objects used do not appear in the next phase if at least one of the operators put them to removal (normally uppercase versions).
In this same phase it is where the objects run through the pipes.
If there is no object at the end of the phase, the program ends.
=== Phase two ===
The positions of the objects are updated one by one, starting at the top left, line by line. Each object tries first to go down, if it can not then try to go in the direction where it points.
All positions are updated at the same time, those who go down have priority over those who go to the right, which have priority over those who go to the left. Here's an example:
 ########
 #1 2#12#
 ########
 # #1##
 # 1 #3##
 #3 2#5 #
 ########
 # 1 9 #
 #35735 #
 ########
Assuming that the odd numbers point to the right and even numbers to the left:
 ########
 # 12#12#
 ########
 # # ##
 # #1##
 #312#35#
 ########
 # 1 #
 #357935#
 ########
== Literals ==
When the source code is converted, the literals are replaced by objects. There are single character literals and multiple characters.
=== Single character ===
The digits (0 to 9) are individually replaced by a numeric object containing that value.
The character I is replaced by the input object.
The character O is replaced by the output object.
=== Multiple character ===
They can be horizontal or vertical. All the characters are replaced by empty spaces except for the first (top left) which is replaced by the object with the corresponding value.
Horizontal	Vertical 	Description
() 	[] 	It contains an integer. Can have a - sign.
"" 	''	It contains a string. Can be used the escape character (\) as in C.
// 	\\ 	It contains a string that identifies one of the constants described below.
{} 	 	It contains a comment. Does not create any object and can not be vertical.
=== Constants ===
ID 	Name 	Type 	Content
ll 	Lowercase letters 	String	abcdefghijklmnopqrstuvwxyz
ul 	Uppercase letters 	String	ABCDEFGHIJKLMNOPQRSTUVWXYZ
al 	All letters 	String	abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
aa 	All ASCII 	String	Contains all ASCII characters (0 to 127)
pa 	Printable ASCII 	String	Contains all printable ASCII characters (32 to 126)
dd 	Decimal digits 	String	0123456789
od 	Octal digits 	String	01234567
lhd 	Lowercase hexadecimal digits	String	0123456789abcdef
uhd 	Uppercase hexadecimal digits	String	0123456789ABCDEF
ahd 	All hexadecimal digits 	String	0123456789abcdefABCDEF
b64 	Base64 	String	ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
b58 	Base58 	String	123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyzAs in bitcoin.
b36 	Base36 	String	0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
rn 	Roman numerals 	String	IVXLCDM
min 	Minimum 	Number	minimum integer that the interpreter can represent.
max 	Maximum 	Number	maximum integer that the interpreter can represent.
number	Character 	String	Use the number to calculate n % 128, then creates a string with the corresponding ASCII character. The number may only be composed of decimal digits (0 to 9).
=== Examples of literals ===
 (-123) ' /dd/
 [ a \
 4 b l {This is a comment}
 5 "zcy\"" l
 6 d \
 ] '
The first object contains the number -123. The second object contains the number 456. The third object contains the string abcd. The fourth object contains the string z y" (Note that the second character was replaced by a space by the previous literal). The fifth object contains the string 0123456789. The sixth object contains the string abcdefghijklmnopqrstuvwxyz.
== Examples ==
=== Hello, World! ===
 "Hello, World!"
 h
=== Cat ===
Infinite
 I
 W
 O
=== Infinite Loop ===
 1
=== Truth-machine ===
 I
 wX
 
 
 nw
 hO
=== Is prime ===
 I
 w#H
 
 P
 w
 O
=== Quine ===
It has a trailing newline character
 "##V ---V\n ---%\n V-< -V\n/92/ | |\nA/110/X| |\n|/10/d-< |\n||---> |\n|V /10/A |\n| #### |\nV X # |\n a /34/A |\n# v### |vH\n X X | #\n W W V |W\n O#O# --<O#\n # # #\n"
 ##V ---V
 ---%
 V-< -V
 /92/ | |
 A/110/X| |
 |/10/d-< |
 ||---> |
 |V /10/A |
 | #### |
 V X # |
 a /34/A |
 # v### |vH
 X X | #
 W W V |W
 O#O# --<O#
 # # #
== Computational class ==
ROOP is turing complete, as it is possible to translate any brainfuck code to it, using the following table. Each section of code goes under the previous. Use a stack with cells of 7 bits, unsigned and without wrapping.
Brainfuck 	ROOP 	Comments	 	 	 	 	 	 	 	 	 	 	 	 		 		
Start 	
\0
0
\
VV	
It goes in the beginning of the program.	 	 	 	 	 	 	 	 	 	 	 	 		 		
> 	 	1# 	v 	V -V 	 	#-%##V
V V \|
 #0|
 p E \|
 # #v|
 M V
 A #C
##|#	 	 	 	 	 	 	 	 		 		
V 	---->	 	 	 	 	 	 	 	 	 	 	 	 	 		 		
< 	 	1#
VV v
 S #	>#
V| 	 	 	 	 	 	 	 	 	 	 	 		 		
+ 	 	
-+V
 V #
 D-V
 V # X	 	# /aa/! 	#	f1# 	X a
 V| #|	 	/aa/	V #	d 	X# X	1d#	# !	V
 V A #
 V V---->#	A #		
- 	 	
-+V
 V #
 D-V
 V # X	 	# /aa/! 	#	f(-1) 	X aC
 V| #|	 	/aa/	V #	d 	X# X	1d#	# !	V
 V A #
 V V---->#	A #		
. 	 	 	 	 	 	 	 	 	 	 	 	 	 	 		 		
%+V 	V # 	D 	V#
VV>1dX
 #
 
 WX
 V O#
V| #	 	 	 	 	 	 	 	 	 	 	 		 		
, 	 	-----V""	| # C
-+V | V###
 V # %-->
 D-V |--<
 V| X V I%--<	1d # V |	## A |
 V| #|# ###V|	-< 	WX 	 	 	1dX	-+->	V V 	A #	#
 V V>
 V A #		
Read a string ending with a new line but takes only the first character.		
[ 	 	 	-------- { <- B }	--V
-+% 	V
 V ##
 DV V
 V# X!	>1d#/aa/	#-V #	f	 	-->	T !
V #V>
 U
 V%V
 MV
 M |------ { -> C }	------ { -> D }
V|	
-+--+<	 	
You have to connect the inputs and outputs with the corresponding ].	 		
] 	 	
-+------ { -> A }
 ------- { -> B }	 	 	 	 	 	 	 	 	 	 	 	 		 		
------ { <- D }	 	
You have to connect the inputs and outputs with the corresponding [.	 	 	 	 	 	 	 	 	 	 	 	 		 		
End 	
H 	
It goes in the end of the program.	 	 	 	 	 	 	 	 	 	 	 	 		 		
== Implementation ==
C++ Implementation in GitHub
Online interpreter
Category:Languages
Category:Two-dimensional languages
Category:Turing complete
Category:Implemented
Category:2015