# Taneb's Esolang Page!

Hello! I'm Taneb and I've made a few esolangs!

## Nandypants

Nandypants is my earliest esolang. It is based on the concept of the NAND operation, and uses two tapes of bits.

Command Effect
`{` Moves tape a one cell leftwards.
`}` Moves tape a one cell rightwards.
`<` Moves tape b one cell leftwards.
`>` Moves tape b one cell rightwards.
`^` Stores the value in tape a NAND the value in tape b into tape a.
`v` Stores the value in tape a NAND the value in tape b into tape b.
[any even number] If this is the first instance of this number, do nothing. Otherwise, return to the first instance of the number.
[any odd number] If this is the last instance of this number, do nothing. Otherwise, advance to the last instance of the number.
`\` Adds the value in tape a to the output stream.
`/` Inserts the next bit from the input stream into tape b.

There is also a dialect called Noryshorts, which differs in that it uses the NOR operation rather than NAND. Both variants are Turing-Complete.

## Numberwang!

Numberwang! is a language based on the British comedy sketch show, That Mitchell and Webb Look, which features the fictional quiz show, Numberwang!, which consists of a pair of individuals shouting seemingly random (and occasionally made up) numbers, occasionally interrupted by the host saying, "That's Numberwang!". This language is in a process of continued developement, so I wouldn't bother trying to implement it at current.

The language is based on Hao Wang's B-Machine, and its memory is stored in a single tape whose cells can be either marked or unmarked. The program also keeps track of the number of operations computed. The language is in the format of a series of terminating positive decimals, separated by exclamation marks. At each step, the digital root of the sum of the number of operations computed, the current number, and its position in the program is calculated, modulo 4. This is then converted to an operation as follows:

Number Operation
2 The "goto" operaton: goes to the command whose location matches the current command's value. If the current command's value is non-integer, it is interprolated linearly between the two values either side of that location, and the next command is the one after the higher of those.
3 iiiiit's Numberwang! Flip the current cell (i.e. if it is marked, erase it, if it is unmarked, mark it). Then the program "12! 4.4! 92! 10! 49.8! 2! 2! 2!" is executed using the current tape and step count.

It is unknown if the language is Turing-Complete, but I suspect it isn't.

## Constantinople

Constantinople is a language, named for the song Istanbul, Not Constantinople. It is my first, and so far only, high level esolang. Memory is stored in an infinite list that can contain either bits or similar infinite lists. By default it contains an infinite amount of 0s, except for the head of the list, which contains another list, filled with 0s. The commands are as follows:

Command Effect
`replace m with n` Replaces the value at m with the value at n.
`repeat n` Starts a repeate block, repeating while n evaluates to 0.
`end` Ends a repeat block.
`in n` Replaces n with a bit from the input stream.
`out n` Adds the value at n to the output stream.
`head n` Returns the very first element in n.
`tail n` Returns the n sans the first element.
`nand m with n` Returns m NAND n

Commands that expect a list (head and tail) behave as though given an infinite list of the same value when given a bit, and commands that expect a list (out, nand), behave as though given the head of a list when given that list. Missing arguments are assumed to be the main list. Constantinople is Turing Complete.

## MIBBLLII

MIBBLLII is a functional programming language cunningly disguised as brainfuck. It is purely functional, and IO is done in Lazy K-esque front-and-back effects style. It uses `[` and `]` as brackets for grouping combinators, and the combinators are as follows:

`+` `λabc.a(bc)` `(.)` or `fmap`
`-` `λabc.acb` `flip`
`.` `λab.a` `const` or `pure` or `return`
`,` `λab.abb` `join`
`<` `λabc.ac(bc)` `ap`
`>` `λa.a` `id`

MIBBLLII is Turing-Complete as it incorporates SKI calculus. The Haskell commands all work individually, but as Haskell does not allow infinite types (such as `a = a -> b`), the translation as a whole won't work.

## Luigi

Luigi is a language named after my favourite Mario character, and is based on the concept of L-Systems. Hence, it uses parralel string-rewriteing. The program consists of the alphabet used (which can contain any printing character except for the semicolon), the initial state, which can also be called the axiom, and a series of rules which consist of a predecessor then a successor, with everything separated by semicolons so the program is in the format:

`;alphabet;initial state;predecessor;successor;predecessor;successor;...`

An interpreter would try to find matches to the predecessorparts of the rules in the current string (starting with the initial state), and replaces any matches with the appropriate successor. Ambiguity is allowed, but its behaviour is implementation-dependant, so use at your own risk!

Luigi is Turing-Complete, as it is possible to translate arbitrary Turing-Machines to it, although no formal proof exists

## Brook

Brook is a language based on the concept of infinite length streams, although at current no program has been written which allows one. A Brook program, during execution, can generate another Brook program, which is executed as soon as it is possible to do so. However, it is impossible to pass any data upwards in a chain. There is also no trivial (although non-trivial ways may exist) to construct infinite loops. Numbers are ignored when not followed directly by either a `^` or a `(`. Data is stored in a first-in-first-out queue.

The loop construct consists of a number, followed by some code enclosed in brackets, e.g. `72(12^)` Commands are as follows:

Command Effect
`n^` Pushes n to the queue.
`v` Pops a number from the queue and discards it.
`U` Pops a number from the queue, and pushes it twice.
`@` Pops a number from the queue, and pushes it once.
`+` Pops two numbers, and pushes their sum.
`-` Pops two numbers, and pushes their absolute difference.
`i` Pushes the ASCII (or Unicode, or whatever) value of the next character from input onto the queue.
`o` Pops a number from the queue, and adds the character with it as its character code to the output.
`c` Pops a number from the queue, and adds the character with it as its character code to the program generated by this program.
`I`, `O`, and `C` These work as their lower-case equivalents, except use numbers directly (in decimal format) rather than converting to or from characters.

## Fueue

Fueue is a queue-based language. The entire data of the program is stored in the same queue as the program. There are a few data types:

• Functions;
• Numbers;
• Blocks of code enclosed in brackets.

Numbers are numbers in base 10, which may be positive or negative, and, if necessary, may be separated by whitespace. Blocks of code are enclosed in square brackets ("[" and "]"). Functions are as follows:

Function Effect Before After
`+` Adds two numbers `+ab...` `...(a+b)`
`-` Negates a number `-a...` `...(-a)`
`*` Multiplies two numbers `*ab...` `...(a*b)`
`/` Integer divides two numbers `/ab...` `...(a/b)`
`%` Logically inverts a number (0 to one, n to 0) `%a...` `...(!a)`
`:` Duplicates a value `:a...` `...aa`
`~` Swaps two values `~ab...` `...ba`
`!` Pops a value `!a...` `...`
`\$` Pushes a number of copies `\$ab...` `...(a lots of b)`
`(` Turns a value into a block `(a...` `...[a]`
`<` Adds another value into a block `<[foo]b...` `...[foob]`
`)` Deblocks a block `)[foo]...` `...foo`
`H` Halts immediately `H...`

Execution is as follows:

• Look at the front element of the queue;
• If it is a numeric value, it is converted to a character and printed;
• If it is a function, and the following elements are the correct type to execute the function, the function is executed and the result is pushed into the back of the queue.
• Otherwise, it is simply sent to the back of the queue.
• If the queue reaches this last stage many times and does a full rotation without changing at all, a character is taken from input and its unicode value is added to the back of the queue.

I was introduced to esoteric programming languages by David Morgan-Mar, who has created a few such languages. One of his languages, BIT, is designed to be easy to read with no unusual concepts. However, it has a few problems:

• The type system is confusing and hard to understand, with distinct bit and address-of-a-bit types;
• It lacks functional purity, which is all the rage these days;
• "PARENTHESIS" is a very long word, and having such things makes it easy to mismatch brackets;
• Binary is hard to understand, as opposed to the much simpler Peano numbers.

So I created the language Real Fast Nora's Hair Salon 3: Shear Disaster Download, which addresses these problems. It is based on the easy to understand λ-calculus, and hence is trivially Turing-complete. IO is Lazy K-esque, with front and back effects.

The main feature of the language is the `LAMBDA` key word. This introduces a lambda expression, which is a function that takes one input and returns a function.

The next feature is the `APPLY` key word. This takes two function, and applies the second to the first, so that the second function is the input to the first.

But how do we use these inputs? This is the job for numbers. `ZERO` is a number, which represents the input to the innermost lambda. A number may be preceded with the key word `ONE MORE THAN`, which makes a bigger number, which represents the input to a lambda one further out.

## COMPLEX

COMPLEX, or COMPutational Language EXtension, is a language inspired by BASIC. BASIC is famous for having line numbers in the program text, allowing programs such as:

```10 PRINT "HELLO"
20 GOTO 10
```

Of course, the line numbers are restricted to non-negative integers. This, from a mathematical perspective, is boring and out-dated. The Gaussian integers were first introduced by Carl Friedrich Gauss in 1832, and we have to wonder why the creators of BASIC seem to be unaware of this advancement. COMPLEX is designed to remedy this. We introduce line numbers ranging across the entire Gaussian integer plane, written as, for example, `-4+2J`. If a compenent is omitted, it is assumed to be zero. This grants us much more flexibility and expressiveness right off the bat! No longer are we railroaded into the natural numbers! No more languishing around in multiples of ten!

However, this does raise the question of what order do we write our lines, as it is common knowledge that the Gaussian integers are as a ring unordered. We solve this by liberating the programmer who can now write their program in whatever order they desire! The interpreter will procede through the program according to two special variables: `VECTORX`, which determines the real component of our direction, and is initially set to 1, and the corresponding, initally 0, imaginary component `VECTORY`. These are the only two special variables. All variables, incidentally, are written in `UPPERCASE` and contain an integer.

By manipulating the variables `VECTORX` and `VECTORY` we provide a new form of control flow, rendering BASIC's famous GOTO, long-considered harmful in all circumstances, redundant, so it is not in the language. What is in the language? Well, each line takes the form of a line number, and a statement. The statements are as follows:

• `SET variable expression` sets the given variable to the result of the given expression;
• `PRINT [expression]` prints the value of each of the zero or more expresssions given; and
• `IF expression statement` executes the given statement if and only if the given expression evaluates to a non-zero value.

These are all the statements a modern programmer will ever need! Unfortunately, COMPLEX is a research language, and the available expressions may seem limited. Fret not! They are conjectured to be sufficient for Turing completeness, meaning that COMPLEX is as powerful as well-used high-level languages like FORTRAN and COBOL. The available expressions are as follows:

• Any non-negative integer constant is a valid expression, evaluating to itself.
• Any variable name is a valid expression, evaluating to the value of that variable.
• If `a` and `b` are valid expressions, then `a + b` is a valid expression, evaluating to the sum of `a` and `b`.
• Likewise, `a - b` is a valid expression, evaluating to the difference between `a` and `b`/

I will finish with an example program, demonstrating the expressiveness and power of COMPLEX! It computes the entire Fibonacci sequence, up to its twentieth element!

```2 SET HI 1
7+4J SET VECTORY 0
3+4J SET HI LO + HI
0 SET N 20
1+4J SET VECTORY 0 - 1
1 SET LO 0
5+4J SET N N-1
3 SET VECTORY 0
0+3J SET VECTORX 1
8+3J SET VECTORX 0 - 1
5 IF N SET VECTORY 1
2+4J SET LO TMP
4+4J SET TMP HI
4 PRINT LO
```