In light of the recent posts and discussions about multidimensional
numbers,today’s pathological language is Recurse, a two-dimensional language – like Befunge, sort of. But I find it more interesting in its own peculiar little
way. It’s actually a function-oriented two-dimensional language where every
function is rectangular.

Underneath the two-dimensional layout, Recurse is based on a pretty simple computational mechanism. There are two stacks of integers, a left stack and a right stack; and a single register containing an integer.

The basic commands are:

1. Push: push the value in the register onto one of the stacks; “{” for the left stack, and “}” for the right stack.
2. Pop: Pop a value from a stack into the register; “[” for the left, “]” for the right.
3. Unconditional set direction: set the direction that the instruction pointer will move. “^” for up, “v” for down, “<” for left, and “>” for right.
4. Load Constant: Load a single digit integer into the register. “0”-“9”.
5. Read character: “?” – read an ascii character, and load it into the register.
6. Write character: “!” – output the register as an ASCII character.
7. Conditional Direction Change: “@” – if the register is 0, don’t turn. If the register is positive, change the direction the the instruction pointer moves counter-clockwise; if it’s negative, change the direction clockwise.
8. Return from function: “#”
9. Add: “a” pop a value l from the left stack, and a value r from the right stack, and set the register to l+r.
10. Subtract: “-” pop a value l from the left stack, and a value r from the right stack, and set the register to l-r.
11. Multiply: “m” pop a value l from the left stack, and a value r from the right stack, and set the register to l*r.
12. Divide: “d” pop a value l from the left stack, and a value r from the right stack, and set the register to l/r.
13. Remainder: pop a value l from the left stack, and a value r from the right stack, and set the register to l mod r.
14. Call function: any other character is treated as the name of a function,
    which is invoked.

A program consists of a rectangular grid. The grid is usually surrounded by “#” characters, with one exception for each direction. These four characters are the entry points for a function. When a function is called, the direction that the instruction pointer is moving is used to select an entry point. So if the pointer is moving down, then the function will be entered from the top entry point, so
that instructions can continue to be executed moving in the same direction. The functions name is the character that appears in both the top and bottom left
corners of the function grid.

When you’re running a function, if the instruction pointer reaches the border, or
encounters a “#”, it will return. Here’s an example to clarify one of the more confusing aspects of that:

Xv##
#^><
><v#
X#^#

This function reverse the direction that the instruction pointer moves. Suppose that the IP is moving down. Then it will enter the function at the “v” on top. “v” tells the IP to keep going down. Then it hits the “^” character one step down, which switches the IP to move up. When it goes to move up, that’s hitting the border – so instead of executing “v”, it returns. It has the same pattern from all four directions, so no matter what way you’re moving, this function will reverse the IP direction.

As usual, we’ll start with a hello world program.

$v###############
>9n_3n{5}aA7A_3v#
#v3A}s}1{n7_n4AnA3A6S8S4n{1Av.}8{m#
#.m{8}.{!.}a{!#
#.!{a}.}s{!#
#.!{s}<
S^#####

Main function
$v####
>0Rf%{{2}sfv#
>@1#v}1}<0#>sf{a#
f^########
Reads a positive decimal integer from the keyboard
The register should be zeroed before calling
Press space to terminate function
Rv#################################
##..........>v....>[#.............{?!{6{8}m}s@>{9}s@>{9}a}5{}a}m{aR#
##..........>[#...>^..............#
R^#################################