feat: configure EOF behavior

Brainfuck specification doesn't define EOF and it's considered an implementation detail

Author: Mee-Tree

src/main/interpreter/InputOutput.scala

@@ -6,23 +6,23 @@ import cats.{Applicative, Id}
 import cats.syntax.all.*
 
 trait InputOutput[F[_]]:
-  def read: F[Either[InputOutputError, Byte]]
+  def read: F[Either[InputOutputError, Option[Byte]]]
   def write(b: Byte): F[Either[InputOutputError, Unit]]
 
 object InputOutput:
   transparent inline def apply[F[_]](using InputOutput[F]): InputOutput[F] = summon
 
-  given id: InputOutput[Id] = make
+  given id(using eof: EOF = EOF.NoChange): InputOutput[Id] = make
 
-  def make[F[_]: Applicative]: InputOutput[F] = new InputOutput[F]:
-    def read           = stdin.pure[F]
-    def write(b: Byte) = stdout(b).pure[F]
+  def make[F[_]: Applicative](using eof: EOF): InputOutput[F] = new InputOutput[F]:
+    def read           = stdin.map(b => if b == -1 then eof.byte else Some(b.toByte)).pure[F]
+    def write(b: Byte) = stdout(b.toChar).pure[F]
 
-  private def stdin: Either[InputOutputError, Byte] =
-    Try((0 max System.in.read).toByte).toEither.leftMap(InputOutputError.read)
+  private def stdin: Either[InputOutputError, Int] =
+    Try(System.in.read).toEither.leftMap(InputOutputError.read)
 
-  private def stdout(b: Byte): Either[InputOutputError, Unit] =
-    Try(System.out.print(b.toChar)).toEither.leftMap(InputOutputError.write)
+  private def stdout(ch: Char): Either[InputOutputError, Unit] =
+    Try(System.out.print(ch)).toEither.leftMap(InputOutputError.write)
 
 enum InputOutputError(msg: String) extends Throwable(msg):
   case Read(msg: String)  extends InputOutputError(s"Read: $msg")
@@ -31,3 +31,16 @@ enum InputOutputError(msg: String) extends Throwable(msg):
 object InputOutputError:
   inline def read(e: Throwable): InputOutputError  = InputOutputError.Read(e.getMessage)
   inline def write(e: Throwable): InputOutputError = InputOutputError.Write(e.getMessage)
+
+enum EOF:
+  /** Return 0 on EOF. */
+  case Zero
+  /** Return -1 (255 as byte) on EOF. */
+  case MinusOne
+  /** Leave unchanged on EOF. */
+  case NoChange
+
+  def byte: Option[Byte] = this match
+    case Zero     => Some(0)
+    case MinusOne => Some(-1)
+    case NoChange => None

src/main/interpreter/Interpreter.scala

@@ -33,7 +33,7 @@ object Interpreter:
       case Command.IncByte    => EitherT.rightT(tape.inc)
       case Command.DecByte    => EitherT.rightT(tape.dec)
       case Command.OutputByte => EitherT(io.write(tape.get)).leftMap(InterpretError.IO(_)).as(tape)
-      case Command.InputByte  => EitherT(io.read).leftMap(InterpretError.IO(_)).map(tape.set)
+      case Command.InputByte  => EitherT(io.read).leftMap(InterpretError.IO(_)).map(_.fold(tape)(tape.set))
       case Command.Loop(cmds) => tape.iterateWhileM(eval(_, cmds))(_.get != 0)
 
 enum InterpretError(msg: String) extends Throwable(msg):

src/test/interpreter/Interpreter.test.scala

@@ -11,12 +11,19 @@ import dev.meetree.brainfuck.core.*
 class InterpreterSpec extends AnyFlatSpec with Matchers with EitherValues:
   import Interpreter.eval
 
-  case class Data(inputs: List[Byte], outputs: List[Byte], faulty: Boolean = false):
-    def read: (Data, Either[InputOutputError, Byte]) =
+  type F[A] = StateT[Id, Data, A]
+
+  given eof: EOF = EOF.NoChange
+  given InputOutput[F] with
+    def read: F[Either[InputOutputError, Option[Byte]]]      = StateT.apply(s => s.read)
+    def write(byte: Byte): F[Either[InputOutputError, Unit]] = StateT.apply(s => s.write(byte))
+
+  case class Data(inputs: List[Byte], outputs: List[Byte], faulty: Boolean = false)(using eof: EOF):
+    def read: (Data, Either[InputOutputError, Option[Byte]]) =
       inputs match
         case _ if faulty  => (this, Left(InputOutputError.Read("read")))
-        case head :: tail => (Data(tail, outputs, faulty), Right(head))
-        case Nil          => (this, Right(0))
+        case head :: tail => (Data(tail, outputs, faulty), Right(Some(head)))
+        case Nil          => (this, Right(eof.byte))
 
     def write(byte: Byte): (Data, Either[InputOutputError, Unit]) =
       if faulty then (this, Left(InputOutputError.Write("write")))
@@ -26,11 +33,6 @@ class InterpreterSpec extends AnyFlatSpec with Matchers with EitherValues:
     final val empty: Data  = Data(Nil, Nil)
     final val faulty: Data = Data.empty.copy(faulty = true)
 
-  type F[A] = StateT[Id, Data, A]
-  given InputOutput[F] with
-    def read: F[Either[InputOutputError, Byte]]              = StateT.apply(s => s.read)
-    def write(byte: Byte): F[Either[InputOutputError, Unit]] = StateT.apply(s => s.write(byte))
-
   val interpreter = Interpreter.make[F]
   import interpreter.interpret