// Shared via this post: // https://www.sololearn.com/post/700610 // Implementing BrainF$%& in Kotlin // A perfect example of improper operator // overloading. Some language symbols could // not be overloaded in Kotlin so were // replaced with ones that could. A noop // instruction was added to force Kotlin // implict typing to figure out the data // type. // Code implemented based on this description: // “Advanced Kotlin syntax abuse” by ωєѕтση // https://link.medium.com/CA9V3Y3FQab // Source code based on with modifications to // work in 1.1: // https://github.com/westonal/KotlinBrainFuck/tree/master/src/main/kotlin/io/github/westonal // Main program to process BF language. fun main(args: Array) = helloWorld() /* Function to process the BF program by displaying the actual code and run it. BF has the following operations: Op Sub Purpose + Increment current cell - Decrement current cell . o Output current cell , Input into current cell (not used) > r Shift up one cell < l Shift down one cell [ Start loop if current cell non zero or skip past end if zero ] End of loop n Noop to allow implict typing The following is a commented version: ++++++++ Set #0 to 8 [ Outer loop for 8 times >++++ Set #1 to 4 [ Inner loop for 4 times >++ Add 2 to #2 >+++ Add 3 to #3 >+++ Add 3 to #4 >+ Increment #5 <<<<- Decrement #1 ] End inner >+ Increment #2 >+ Increment #3 >- Decrement #4 >>+ Increment #6 [<]<- Decrement #0 ] End outer Cells at this point: #0 = 0 #1 = 0 #2 = 8*(4*2+1) = 72 #3 = 8*(4*3+1) = 104 #4 = 8*(4*3-1) = 88 #5 = 8*4*1 = 32 #6 = 8*1 = 8 >>. Display #2 of 72 or 'H' >---. Adjust #3 for display of 101 or 'e' +++++++. Adjust #3 for display of 108 or 'l' . Display #3 for 108 or 'l' +++. Adjust #3 for display of 111 or 'o' >>. Display #5 for 32 or space <-. Decrement #4 for display of 87 or 'W' <. Display #3 for 111 or 'o' +++. Adjust #3 for 114 or 'r' ------. Adjust #3 for 108 or 'l' --------. Adjust #3 for 100 or 'd' >>+. Increment #5 & display 33 or '!' >++. Add 2 to #6 & display 10 or '\n' */ fun helloWorld() { with ( + + + + + + + + n [ r + + + + n [ r + + r + + + r + + + r + l l l l - n ] r + r + r - r r + n [ l ] l - n ] r r o r - - - o + + + + + + + o o + + + o r r o l - o l o + + + o - - - - - - o - - - - - - - - o r r + o r + + o ) { println("Running: "+this); this() } } // helloWorld // Allocate variables to be used as the // far rightmost term of our expression. // Noop to allow implict typing. Output to // display the current cell. Right to // shift up a cell. Left to shift down a // cell. val n = Program(emptyList()) val o = n.append(Command.Print) val r = n.append(Command.MoveRight) val l = n.append(Command.MoveLeft) // Extend the Program class with methods // to allow chaining commands to the left // of the expression overloading our // variables for output, right, and left. infix fun Program.l(program: Program) = append(Command.MoveLeft).append(program) infix fun Program.r(program: Program) = append(Command.MoveRight).append(program) infix fun Program.o(program: Program) = append(Command.Print).append(program) // Extend the Program class with operator // methods for plus and minus, with their // unary versions. The rightmost term // uses the regular version. The rest use // the unary version. operator fun Program.unaryPlus() = n.append(Command.Add).append(this) operator fun Program.plus(program: Program) = append(Command.Add).append(program) operator fun Program.unaryMinus() = n.append(Command.Subtract).append(this) operator fun Program.minus(program: Program) = append(Command.Subtract).append(program) // Extend the Program class array subscript // operator method to be our loop. operator fun Program.get(loopInner: Program) = append(Command.Loop(loopInner)) // Class to emulate our BF hardware. // Properties are the memory size, the // cells of our memory, and the index // to the current cell. class Tape(size: Int = 30000) { private val data = Array(size) { 0 } private var pointer = 0; // Method to increment our current cell. fun add() { data[pointer]++ } // add // Method to decrement our current cell. fun subtract() { data[pointer]-- } // subtract // Method to shift up one cell. fun moveRight() { pointer++ } // moveRight // Method to shift down one cell. fun moveLeft() { pointer-- } // moveLeft // Method to return the current cell's // value. fun current() = data[pointer] // Method to return the current cell's // value as a character. fun currentAsChar() = current().toChar() } // Tape // Extend the Program class with an invoke // method to interpret the BF program. // Provide our hardware emulator and // the Java character display as defaults // if our arguments are missing. operator fun Program.invoke( tape: Tape = Tape(), writer: java.io.PrintWriter = java.io.PrintWriter( System.out.writer())) { // For each command in our program, tell // the emulator to execute it. The loop // is a special case. while the current // cell is not zero, recurse on the loop's // program. for (command in commands) { when (command) { is Command.Add -> tape.add() is Command.Subtract -> tape.subtract() is Command.MoveRight -> tape.moveRight() is Command.MoveLeft -> tape.moveLeft() is Command.Print -> writer.print(tape.currentAsChar()) is Command.Loop -> while (tape.current() != 0) command.loopContent(tape, writer) } // when } // for // Flush the display buffers. writer.flush() } // invoke // Class to store the BF program. Property // is the list of commands defaulting to // empty if not specified. class Program(val commands: List = emptyList()) { // Method to append the command to our // commands creating a new program. fun append(command: Command): Program { return Program(commands+listOf(command)) } // Method to append the other program's // commands to ours creating a new program. fun append(program: Program): Program { return Program(commands+program.commands) } // Method to generate the program's command // list as a display string. override fun toString(): String = commands.joinToString(separator = "") } // Program // Class of all supported BF commands. sealed class Command { // Add command with method to generate its // display string. object Add : Command() { override fun toString() = "+" } // Add // Subtract command with method to // generate its display string. object Subtract : Command() { override fun toString() = "-" } // Subtract // Shift up command with method to // generate its display string. object MoveRight : Command() { override fun toString() = ">" } // MoveRight // Shift down command with method to // generate its display string. object MoveLeft : Command() { override fun toString() = "<" } // MoveLeft // Output command with method to // generate its display string. object Print : Command() { override fun toString() = "." } // Print // Loop command with method to generate // its display string. class Loop(val loopContent: Program) : Command() { override fun toString() = "[$loopContent]" } // Loop } // Command

BrainF$%& mn