Minor tweaks

Author: Dash-Lambda

README.md

@@ -375,5 +375,37 @@ This interpreter is also a little unique in that it's the only interpreter in Es
 
 The reason I had to use mutable states to accomplish this is that I have to perform the evaluation in the same level as the rest of the expression in order to not blow up the call stack. If I simply made the result a `lazy val` that made a new call to `eval`, that would introduce a recursion that can't be optimized away with trampolining. The moment I figure out a way to do this without mutable state, though, I'm changing it.
 
+### How the Interface Code Works
+You may notice odd-looking structures like this in the code for several interface handlers:
+```scala
+Trampoline.doOrElse(state){
+  DoOrOp(args.get("s"), "Missing Source File", eio){src =>
+    DoOrOp(getLang(args, "l", "s"), "Unrecognized Language or File Extension", eio){lang =>
+      DoOrOp(findTranslator(state, lang, state.interpNames), "Language Not Recognized", eio){
+        case (inam, t) =>
+          DoOrErr(EsoFileReader.readFile(src, normLineFlag), eio){progRaw =>
+            DoOrErr(t(progRaw), eio){prog =>
+              TimeIt(state.interps(inam)(state.config)(prog)) match{
+                case (i, dur) =>
+                  DoOrErr(i, eio){r =>
+                    DoOrErr(inputs, eio){inp =>
+                      TimeIt{tryAll{printer(olim(r(inp)))}} match{
+                        case (flg, rdr) => flg match{
+                          case Failure(e) =>
+                            if(timeFlg) eio.println(s"\nError: $e\nProgram failed in ${rdr}ms")
+                            else eio.println(s"\nError: $e")
+                          case Success(_) =>
+                            if(timeFlg) eio.println(s"\nProgram completed in ${rdr}ms")
+                            else eio.println()}}
+                      Done{state}}}}}}}}}}
+```
+These actually represent most of the core logic. Eso uses `Try` monads for most of its error handling, as well as `Option`s for a lot of faillable tasks, so if the code were to use a normal imperative or structural style there would be a lot of redundant code for checking whether or not something failed and breaking the flow.
+
+These structures just nest each step into the previous one it's dependent on. You can see that the first layer tries to get the source file, then the second layer tries to find the language to use, and so-on. Each layer tries to do something, and either passes the result to the next layer or short-circuits with a failure. This works out to be quite an elegant way to represent multi-step IO interactions.
+
+You'll also notice that the whole thing is wrapped in a `Trampoline` method. If you were to just arbitrarily nest things like this, you would be pointlessly eating up the call stack -so instead, each layer is actually a wrapper that returns the next layer. So, during execution it's actually going into a layer then coming out of that layer with the next one, only ever going down into one layer at a time. This is called trampolining, and it's a common way to optimize recursive structures that could otherwise blow up the call stack.
+
+Of course, Eso wouldn't need special handling of trampolines if it had full TCE, but that's a matter for future JVM versions to address.
+
 ### Building
 I use [SBT assembly](https://github.com/sbt/sbt-assembly). This repo should give you everything you need to build it, just put it in a folder, run SBT from that directory, let it do its thing, then run assembly.

build.sbt

@@ -8,7 +8,7 @@ lazy val root = (project in file("."))
     name := "Eso",
     logBuffered in Test := false,
     parallelExecution in Test := false,
-    assemblyJarName in assembly := "Eso.jar",
+    assemblyJarName in assembly := s"Eso-${version.value}.jar",
     scalacOptions ++= Seq("-deprecation", "-feature"),
     testOptions in Test += Tests.Argument(TestFrameworks.ScalaTest, "-fFW", "esoTestLog.txt", "-o"),
     resolvers ++= Seq(

esoTestLog.txt

@@ -150,6 +150,7 @@ Unlambda
 - should run hworld.unl correctly
 - should run alphatest.unl correctly
 - should run adventure.unl correctly
+- should run primes.unl correctly
 WSAssemblySpec:
 WSAssembly
 - should preserve the behavior of hworld.wsa
@@ -221,8 +222,8 @@ MetatapeSpec:
 Metatape
 - should run hworld.mt correctly
 - should run bitWidth.mt correctly
-Run completed in 1 minute, 51 seconds.
-Total number of tests run: 126
+Run completed in 1 minute, 37 seconds.
+Total number of tests run: 127
 Suites: completed 46, aborted 0
-Tests: succeeded 126, failed 0, canceled 0, ignored 0, pending 0
+Tests: succeeded 127, failed 0, canceled 0, ignored 0, pending 0
 All tests passed.

mycologyReport.txt

@@ -79,10 +79,10 @@ y claims all of the following:
 	That the offset of the IP was ( 0 0 )
 	That the least point containing a non-space cell is ( -3 -2 )
 	That the greatest point, relative to that point, is ( 183 911 )
-	That the day of the month is 27 
+	That the day of the month is 28 
 	That the month is 2 
 	That the year is 2020 
-	That the time is 07 : 36 : 53 
+	That the time is 04 : 39 : 47 
 	That the size of the stack stack is 1 
 	That the stack sizes are [ 0 ] from top to bottom
 	That the command-line arguments were: [ null ]
@@ -148,8 +148,8 @@ GOOD: all of A-Z reflected
 Testing fingerprint HRTI... loaded.
 UNDEF: G gives clock granularity as 1000 microseconds
 GOOD: T reflected when called before M
-UNDEF: S pushed 530000 
-UNDEF: T after M pushed 0 and a second T, after 675 ys, pushed 11827000 
+UNDEF: S pushed 217000 
+UNDEF: T after M pushed 1000 and a second T, after 675 ys, pushed 12146000 
 GOOD: ET reflected
 
 Testing fingerprint MODE... not loaded.

src/main/scala/ui/EsoExecutor.scala

@@ -30,7 +30,8 @@ case class EsoExecutor(cmds: Vector[InterfaceHandler]) extends EsoObj{
   def showHelp(): Unit = {
     val cStr = cmds.map(h => s"- ${h.nam} ${h.helpStr}").sorted.mkString("\n")
     val hStr =
-      s"""|Commands:
+      s"""|Version: ${getClass.getPackage.getImplementationVersion}
+          |Commands:
           |$cStr
           |
           |Syntax:

src/main/scala/ui/EsoIOInterface.scala

@@ -7,6 +7,8 @@ import scala.io.StdIn
 trait EsoIOInterface extends EsoObj{
   def readLine: String
   def readLine(str: String): String
+  def linesIterator: Iterator[String] = Iterator.continually(readLine)
+  def charsIterator: Iterator[Char] = linesIterator.flatMap(ln => ln + '\n')
 
   def print(x: Any): Unit
   def println(x: Any): Unit

src/main/scala/ui/InterfaceHandlers.scala

@@ -79,9 +79,9 @@ case class RunProgHandler(eio: EsoIOInterface = EsoConsoleInterface) extends Int
     def inputs: Try[LazyList[Char]] = args.get("i") match{
       case Some(fnam) =>
         val fStr = EsoFileReader.readFile(fnam, normLineFlag) map (s => (s + state.nums("fileEOF").toChar).to(LazyList).map{c => if(echoFInp) eio.print(c); c})
-        if(appFlg) fStr map (s => s :++ LazyList.continually(eio.readLine + '\n').flatten)
+        if(appFlg) fStr map (s => s :++ eio.charsIterator)
         else fStr
-      case None => Success(LazyList.continually(eio.readLine + '\n').flatten)}
+      case None => Success(eio.charsIterator.to(LazyList))}
 
     def printer(out: Seq[Char]): Unit = args.get("o") match{
       case Some(onam) =>

src/test/scala/unlambda/UnlambdaSpec.scala

@@ -1,10 +1,12 @@
 package unlambda
 
+import common.PrimeNumTools
 import common_test.EsoSpec
 
 class UnlambdaSpec extends EsoSpec{
   testAllAgainstOutputAutoLimit(Unlambda, defaultConfig.set("echoFileInp", b=false))(
     ("hworld.unl", "", "Hello world\n", false),
     ("alphatest.unl", "", "abcdefghijklmnopqrstuvwxyz0123456789\n", false),
-    ("adventure.unl", grabFile("winAdventure.txt"), grabFile("adventureRef.txt"), true))
+    ("adventure.unl", grabFile("winAdventure.txt"), grabFile("adventureRef.txt"), true),
+    ("primes.unl", "", PrimeNumTools.primesLazy.take(100).mkString("\n"), true))
 }