Betaload

Betaload is an esoteric programming language created by user:Challenger5. It is a derivative of Underload.
Betaload adds the concept of environments: An environment is a space where commands can be executed. Each environment has two stacks: the standard Underload stack of strings, and a stack of sub-environments.
Each Betaload environment can be in one of two possible modes: S-mode or E-mode. These affect whether certain commands act on the string stack or the environment stack. It is recommended that code should generally stay in S-mode; all code on E-mode should be enclosed between ; (the command to toggle modes) and should avoid using instructions that only affect the string stack.
Betaload was designed to make Underload more usable by providing a mechanism for input as well as for a form of object-orientation (or at least grouping of related functionality). It is backwards compatible with Underload (provided that no invalid commands are used).
== Commands ==
Command	Alias 	Effect in S-mode 	Effect in E-mode
~ 	swap 	Swap the two values on top of the string stack. 	Swap the two values on top of the environment stack.
: 	dup 	Duplicate the value on top of the string stack. 	Duplicate the value on top of the environment stack.
! 	drop 	Delete the value on top of the string stack. 	Delete the value on top of the environment stack.
* 	cat 	Concatenate the values on top of the string stack. 	Concatenate the values on top of the string stack.
(x) 	push 	Push the string onto the string stack. 	Push the string onto the string stack.
a 	esc 	Enclose the top value on the string stack in parenthesis. 	Behavior described below.
^ 	exec 	Execute the value on top of the string stack. 	Execute the value on top of the string stack.
S 	write 	Print the value on top of the string stack. 	Print the value on top of the string stack.
R 	read 	Behavior described below. 	Behavior described below.
; 	mode 	Switch to E-mode. 	Switch to S-mode.
# 	env 	Create a new environment and put it on top of the stack. 	Create a new environment and put it on top of the stack.
> 	send 	Move a string from the current environment to the one on top of the stack.	Pop an environment and put it into the new top environment.
< 	extract	Move a string from the environment on top of the stack to the current one.	Move an environment from the top environment's stack to this one.
{c} 	enter 	Execute the code c from the frame of reference of the top environment. 	Execute the code c from the frame of reference of the top environment.
== Complex Commands ==
The command a, when executed in E-mode, will pop an environment from the stack and push onto the string stack the code necessary to create that environment. For example, #{(foo)(bar)~(baz)#>};a; will push #{(bar)(foo)#{(baz)}} onto the string stack. It essentially un-evals the environment, just like executing a on a string unevals that string. This allows for environments to be manipulated like strings on the string stack. For example, ;aa;~*;a;*^ will rotate the top three environments on the environment stack.
The command R, when executed, will create a dictionary mapping characters to strings. While the top value on the stack is a single character, it will pop that character, pop another string from the stack, and add them to the dictionary. Then, it will read input from STDIN. Every character in the string read will be replaced with its corresponding value in the dictionary (unless the value is not in the dictionary, in which case it will be ignored.) This new string will be pushed to the stack.
== Examples ==
Cat Program (only functions with digits 0-9):
(a(:^)*(This string is here to act as a stopping point for R.
It will be removed by R.
)(
)!(0):(
)!(1):(
)!(2):(
)!(3):(
)!(4):(
)!(5):(
)!(6):(
)!(7):(
)!(8):(
)!(9):(
)!RS):^
It infinitely reads a string of digits and replaces them with the code to print that digit, and then executes the resulting string.
Note that it has not been tested and might not work.
== Implementations ==
An implementation can be found on github. Note that it has some weird quirks like treating { and } separately (so you can have things like (foo)#{(}(bar){)^}), but it supports all the specified behavior correctly.
Category:Languages
Category:Stack-based
Category:Implemented
Category:Turing complete
Category:2016