AI-Generated Esolang

From Esolang
Jump to navigation Jump to search

AI-Generated Esolang is an esolang by User:BoundedBeans and also InferKit, a text generating machine learning algorithm.

Storage

It has a character, a byte tape, a character vector, and a list of strings.

Instruction

Using brainfuck instructions as a base, the following commands were generated:

] - if there is an equal sign at the beginning of the string (at the pointer changed by "), enter (input) the 
    numerical code for the character (I say this also moves the string pointer forwards)
[[ - Highlight the string. The code (string) will be copied from the cell at (so I guess eval??)
++ - Increment and decrement the memory cell at the pointer (for the purpose of usability, 
     this will be interpreted as: increment the current cell, move the pointer right, decrement, move pointer left
>
<
. - (basically the brainfuck instructions copied with different wording)
{ - are equivalent to + , - and +- . (so I will interpret this as, increment, move pointer right, input, move pointer right, 
    decrement, move pointer right, waste useless resources to increment and decrement (this is required), output)
} - (it gives no description, so I'll interpret this as halting the program)
|(1) - Constructs and returns a slice of std::vector<char> . (huh? ok, we'll just return a random slice of the character vector 
       and store it into the tape to the right of the current cell.)
|(2) - Returns a (okay, so just change the current character to 'a' I guess?)
(| should be followed by either 1 or 2)

At this point commands were looking thin, so the commands were modified to change things up a bit.

0.5 - Skip 1,2,3,0,1,2,3,1 (I'll interpret this as: If the cell at the pointer is 0, skip the next command and move the pointer forward
      If the cell at the pointer is still zero, skip two commands and move the pointer two cells forward
      If the cell at the pointer is still zero, skip three commands and move the pointer three cells forward
      If the cell at the pointer is still zero, skip no commands and move the pointer one cell forward
      If the cell at the pointer is still zero, skip two commands and move the pointer three cells forward
      If the cell at the pointer is still zero, skip the next command)
"   - Find an empty cell to replace (save the current cell, move the pointer right until a zero cell is found, put the saved number into the zero cell)
0 - Select each message to jump the nth step (go through the list of strings, if you find one that has a parsable number, jump forward that many cells. 
    I say it saves the position of the message, and progresses further each time, eventually wrapping around)
new 1.F - Jump forward (skip n commands, where n is the cell at the pointer)
new 0   - Jump backwards (same as jump forwards, but backwards)
new 2.F - Jump forwards (in the interest of not having duplicate commands, I say this jumps the ascii code of the current character forwards)
G - Jump the amount of cells at the pointer (so there can be multiple cells per pointer now. 
    No way. This will instead jump the number of non-zero cells in a row to the left of the pointer)
H - Jump the file name for the current executable (so now we have labels. Okay I guess. Jump to the label of the file name for the current executable that's running)
F5 - ... (I say this changes the file name to the string at the pointer of the list of strings, then moves that pointer forwards)
Jump the current user. (no command name apparently, so we'll just use the command description as the instruction. )
     This will jump to the label corresponding to the name of the user. I guess maybe this could be useful for personal unsharable programs???)
and the new executable is now visible. (okay, this puts the executable in full-screen mode)
The (that's all. I'll use this as an opportunity to add some extra flow control. This acts like the 3 in 123)

That seems sufficient.

Syntax

Start with the initial first character, followed by the contents of the character vector (which is only useful for randomness and can't be changed). Then a blank line, and then all of the strings, followed by a blank line. This means strings cannot be empty or have newlines in them. This should be followed by the commands, each on their own line.