Yeefunge

Yeefunge is a Befunge-inspired programming language made by me, User:LEOMOK. It is inspired by +Output, but includes more features.

The Basics

Like +Output, Yeefunge is two-dimensional. The arrows <, >, ^ and v rotate the instruction pointer (IP) left, right, up and down respectively. The program ends once a semicolon ; is reached.

Yeefunge operates on a single stack of numbers, strings and arrays.

Numbers

To push a number, you simply write its decimal representation, as a run of digits with optionally a decimal point at the start or middle. They may also contain a minus sign at the start. They must be written in the same direction as the IP.

For example:

   > 123 0.45 -1 v
                 -
                 9
                 7
   ; 123234 227. <

This pushes the numbers 123, 0.45, -1, -97, 0.722 and 432321 to the stack.

Now you might be thinking: "Hang on, isn't the minus sign also used for subtraction? How will the interpreter tell which to use?"

The answer is really simple. The interpreter checks if the character after the minus sign (in the current direction) is a digit. If not, the minus sign does subtraction.

Strings

A double quote " will push all characters up to the next double quote as a string. Like numbers, strings are pushed in the same direction as the IP. For example:

   >               v
   ;"Hello, world!"<

will push "!dlrow ,olleH", not "Hello, world!", as the IP is going left when the string is pushed.

You can also push a single character with a single quote ', for example 'a or '\x86.

Unlike in +Output, strings may contain these escape codes:

• \" - a double quote
• \\ - a backslash
• \n - a newline
• \t - a tab
• \x00 - a one-byte Unicode character
  (hex digits can be uppercase or lowercase)
• \u0000 - a two-byte Unicode character
• \U000000 - a three-byte Unicode character

When a backslash is encountered, the IP will take the next 1-7 characters (depending on the first character after the backslash) and treat them specially.

Arrays

Arrays are created using square brackets [ and ]. When a [ is encountered, the current size of the stack is marked, and ] will merge all values from the last marked point into an array.

Unlike in traditional programming languages, an unmatched ] does not throw an error. Instead, it groups the whole stack into an array.

Putting it all together

With all three data types, it is possible to create complex structures like these:

   >[1 [2 "text\n" v
   ;               -
   \               5
   \               7
   '               '
   9               a
   .               ]
   ^["cdefgh" 56.7-<

This will push the array [1, [2, "text\n", -57, "a"], -7.65, "hgfedc"], the number 0.9, and a string containing only a backslash.

Instructions

All indexing starts from 0.

Stack operations

Caption text

Instruction	Popped values	What it does
:		Duplicate the top stack value.
$		Remove the top stack value.
\		Swap the top two stack values.
@		Rotate the top three stack values clockwise.
	Example	Example
Example	Example	Example
Example	Example	Example

General operations

Instruction	Popped values	What it does
!	x	Push 1 if x is zero, empty string or empty array, else 0.
+	x, y	Push y + x. If both are strings or arrays, concatenate.
-	x, y	Push y - x. If followed by a digit, included as part of the number.
*	x, y	Push y * x. If one is a number and one is a string/array, repeat the string/array that many times.
/	x, y	Push y / x. If a is 0, throw an exception.
%	x, y	Push y mod x, with the sign of a. If a is 0, throw an exception.
~	x, y	Push y to the power of x. 0 to the power of 0 is 1.
=	x, y	Push 1 if y has the same type and value as x, else 0. Arrays are not compared by reference.
(	x, y	Push 1 if y is less than x, else 0. If both are strings, compare lexicographically.
)	x, y	Push 1 if y is greater than x, else 0. If both are strings, compare lexicographically.

List and string operations

Instruction	Popped values	What it does
&	x, y	Push y[x]. x can be a single index or a list of indices.
a	x, y	Append y to x.
c	x, y	Split y by x into an array. If x is a number, split at every n characters.
h	x, y	Take the first y values of x.
j	x, y	Join y by x.
l	x	Push length of x.
r	x, y	Push range of numbers x (inclusive) to y (exclusive).
t	x, y	Drop the first y values of x.
x	x, y	Push index of first occurrence of y in x. -1 if not found.
y	x, y, z	Insert z at position y of x.
z	x, y	Delete element y of x.
R	x	Push a random value in x.
S	x	Push x sorted.
X	x, y, z	If y is a number, set z[y] to x. Else, replace all occurences of z with y in x.
Z	x	Dump the values of x onto the stack.

Conversions

Instruction	Popped values	What it does
n	x	Convert x to number. If x is non-numeric, push x back.
s	x	Convert to string.
u	x	If x is a number, convert to Unicode character. If x is a list of numbers, convert to Unicode string. If x is a string, convert to list of Unicode codepoints.
b	x, y	If x is a number, push base-x digits of y as an array. If x is an array, interpret it as a base-y number.