Exechars

Exechars is a golfing language. It is based on Execode, with much of the features inherited from it.
Exechars is not a pure golfing language, since Execode was designed for a balance of ease for several things. But its focus on functions (which is the only form of control flow in Exechars) gives it advantage over the other golfing languages for more complex programs, as functions means reusable code. Also, its programs are very compact for its simplicity (only 12 commands excluding I/O and termination), and it can do stuff that are impossible for many other esolangs with its unique features.
 
Exechars can also be treated as a more complete version of Execode, with many of the unintended restrictions fixed by features added in Exechars.
The name Exechars refers to its similarity to Execode, and the fact that its commands are individual characters instead of lines like in Execode.
== Syntax ==
=== Numbers and ID ===
In Exechars, anything except the valid commands are treated as number literals, and numbers are in hexadecimal.
The "names" of variables, stacks/deques, and functions must be numbers, which will be referred to as IDs. If a v is appended to the number, it instead loads the value of variable with ID x as the number.
The IDs of variables, stacks, and functions are non-overlapping, so you can for example have both a variable and a stack with ID 135.
The special EOF code is 65535 (ffff in hexadecimal), when popping from an empty stack or reading EOF from input, it is given.
A number ends with a valid command, in case the end of a program, t.
=== Commands ===
A valid command must be followed by a number, that even includes t (at least in the original implementation). The 2-number commands such as ? and ^ counts as 2 commands, so for conditionals and repeats (note that the repeat counts as one command!) a function is needed for them.
=== Defining ===
Unlike Execode, there's usually no need to define a variable or stack before usage, but instead they're automatically defined (assuming they're previously 0/empty) when using them. Sometimes a command do require a variable to be defined first, like comparison, in that case you can define it using +x-x.
== Command list ==
The symbols and letters below are valid commands. Any 'x' in this list refers to a number.
Command	Description
+x 	increases the variable with ID x by 1
-x 	decreases the variable with ID x by 1
(x 	begin definition of a function, ends with ), the code in between are not executed right away, but instead executes when the function ID x is called.
^x>y 	push variable x to stack y
*x>y 	pops one item from stack x to variable y
&x 	reverses stack x, so it's valid to consider the stacks in Exechars as deques
/x 	call function x
?x=y 	skip the next instruction if variable x and y are not equal
?x!y 	skip the next instruction if variable x and y are equal
?x<y 	skip the next instruction if variable x > y
ix 	reads one value from input and sets variable x to it
ox 	output variable x as character
nx 	output variable x as number (without newline, unlike Execode)
sx 	output stack x at a string
lx 	output stack x as individual numbers
rx 	the next command will repeat x times
t 	terminates the program, some interpreters force this
== Examples ==
Most of the current examples listed here are not optimal.
=== Truth machine ===
 i0+1-1(0n0?0!1/0)/0t
=== Hello, World! ===
 r48+0o0r65+1o1r6c+2o2o2r6f+3o3r2c+4o4r20+5o5r57+6o6o3r72+7o7o2r64+8o8+5o5t
A second way using input (input 72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33):
 (0i0?0!1/1)(1^0>0/0)rffff+1/0s0t
A third way using a stack:
 (0^2>0)r48+0^0>0r65+1^1>0r6c+2r2/0r6f+3^3>0r2c+4^4>0r20+5^5>0r57+6^6>0^3>0r72+7^7>0^2>0r64+8^8>0+5^5>0s0t
=== Addition-only calculator * ===
 i0i1r2b+ar3d+b+10-10(0+3?3<1/0)(1+4?4!0/1)(2+2-0?0!10/2)(3+2-1?1!10/3)/0/1/2/3n4oan3obn2t
A much shorter way, not possible with Execode:
 i0i1r2b+ar3d+br0v+2r1v+2n0oan1obn2t
Modify it trivially to get a subtraction-only calculator:
 i0i1r2d+ar3d+b+10-10(0+3?3<1/0)(1+4?4!0/1)(2+2-0?0!10/2)(3-2-1?1!10/3)/0/1/2/3n4oan3obn2t
The shorter way:
 i0i1r2d+ar3d+br0v+2r1v-2n0oan1obn2t
=== Fibonacci sequence ===
 +0+1+a-ara+b(0+2+3-0?0!a/0)(1+2+4-1?1!a/1)(2+0-4?4!a/2)(3+1-2?2!a/3)(4/0/1/2/3n1ob/4)n1obn1ob/4t
Shorter way:
 +0+1ra+3(0r0v+2r1v+2r0v-0r1v+0r1v-1r2v+1r2v-2n1o3/0)n0o3n1o3/0t
=== Looping counter ===
 ra+1+2-2+3(0n2-3+4?3!2/0?3=2/1)(1-4+3?4!2/1)(2/0o1+3/2)/2t
=== Deadfish interpreter ===
 (64-0)(69+0)(6fn0)(73r0v+5-5r0v+6r5v/2r5v-5r6v-6)(2r6v+0)(0i2?2=at0/2v?0=3/1?0=4+0/0)(1r100-0)r100+3-4rffff+a+0-0/0t
=== Bitwise Cyclic Tag interpreter ** ===
 +0^0>1(0l1*0>0&0^0>0&0?0=b/a/0v)(1*0>1&0^1>0&0*1>2^2>1?2!b/3/0)(3&1^1>1&1)(2i4^4>0?4!c/2)(a*1>a)+b-brffff+c/2*0>a&0/0t
* Input two numbers, such as 16,35
** Input the sequence of bits separated by commas as the program, the initial data is always 1
== Computational class ==
Like in Execode, the Bitwise Cyclic Tag interpreter above proves Exechars Turing-complete, since storage is unbounded. The fixed size reading issue is also fixed with the EOF code.
== Techniques ==
To truly bring out the potential of Exechars, you need to know how the commands can be combined to achieve various things.
=== Functions ===
As the only form of control flow, functions are very important. If something seems hard to solve, maybe you just need to create more functions.
==== Conditional function call ====
 ?0<1^0>2
How to fix that buggy code? Easy! Just create a new function:
 (0^0>2)?0<1/0
==== Switch statement ====
Use /xv and switch statements are so easy:
 (0...)(1...)(2...)(xiy/yv)
See Deadfish interpreter above as an example.
==== While loop ====
To make a loop like those in bf, just do something like this:
 +z-z(x...?y!z/x)
=== Variables ===
==== Variable IDing techniques ====
For longer programs, it's best to ID the variables (actually constants) set to ASCII values, and those that are actually used (the actual variables) using different schemes.
==== Variable duplication ====
The fastest way to duplicate variables is (surprisingly) through stacks, since variables don't get affected when pushed onto a stack:
 ^x>z*z>y
And here's another short way, not possible with Execode:
 rxv+y
==== Zero a variable ====
 rxv-x
==== Addition and subtraction ====
See the addition/subtraction-only calculator and Fibonacci sequence programs above.
==== Multiplication ====
See Deadfish interpreter above.
=== Stacks/deques ===
==== Basic operations ====
PEEK
 *x>y^y>x
DUP
 *x>y^y>x^y>x
SWAP
 *x>y*x>z^y>x^z>x
==== As a queue ====
To use the stack/deque as a queue, use & whenever you're pushing or popping and your previous operation with the stack/deque is the other one:
 ^y>x&x*x>z&x
 ...
== External resources ==
* Implementation in Python, based on the Execode original implementation
Category:Languages
Category:Golfing language
Category:2024
Category:Implemented
Category:Stack-based
Category:Deque-based
Category:Functional paradigm
Category:Turing complete