Add Abstraction Eliminators

Dash-Lambda · Dash-Lambda · commit 91e6d6df6db3 · 2020-03-03T19:56:57.000-05:00
diff --git a/README.md b/README.md
@@ -29,6 +29,7 @@
     - [On the Befunge-98 Interpreter](#on-the-befunge-98-interpreter)
     - [On the LazyK Interpreter](#on-the-lazyk-interpreter)
     - [How the Interface Code Works](#how-the-interface-code-works)
+    - [Abstraction Eliminators](#abstraction-eliminators)
     - [Building](#building)
 
 ## Purpose of Eso
@@ -408,5 +409,11 @@ You'll also notice that the whole thing is wrapped in a `Trampoline` method. If
 
 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.
 
+###Abstraction Eliminators
+For some combinator-calculus languages without support for lambda expressions, Eso provides abstraction eliminators. These are special transpilers that turn all lambda expressions into combinator expressions. For example, if you wanted to run abstraction elimination on an Unlambda program, you would type:
+```
+Eso> transpile -s example.txt -o example.unl -sl Lambda_Calculus
+```
+
 ### 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.
diff --git a/build.sbt b/build.sbt
@@ -1,5 +1,5 @@
 ThisBuild / scalaVersion     := "2.13.0"
-ThisBuild / version          := "2.3.1"
+ThisBuild / version          := "2.4.0"
 ThisBuild / organization     := "com.github.dashlambda"
 ThisBuild / organizationName := "dashlambda"
 
diff --git a/esoTestLog.txt b/esoTestLog.txt
@@ -61,6 +61,9 @@ RunProgHandler
 DeadfishSpec:
 Deadfish
 - should run hworld.df correctly
+LambdaToLazyKUnlSpec:
+Lambda_Calculus => LazyK_Unlambda
+- should preserve the behavior of absSpaceLazyK.txt
 NULLSpec:
 NULL
 - should run hworld.nul correctly
@@ -78,8 +81,8 @@ WhiteSpace
 - should run hworld.ws correctly
 OokSpec:
 Ook <=> BrainFuck
-- should Preserve the behavior of hworld.ook when translating from BrainFuck to Ook
-- should Preserve the behavior of hworld.b when translating from Ook to BrainFuck
+- should preserve the behavior of hworld.ook when translating from BrainFuck to Ook
+- should preserve the behavior of hworld.b when translating from Ook to BrainFuck
 PreludeSpec:
 Prelude
 - should run hworld.pld correctly in parallel
@@ -120,8 +123,8 @@ GlyphoShorthand <=> Glypho
 - should preserve the behavior of hworld.glo
 FlufflePuffSpec:
 FlufflePuff <=> BrainFuck
-- should Preserve the behavior of hworld.fl when translating from BrainFuck to FlufflePuff
-- should Preserve the behavior of hworld.b when translating from FlufflePuff to BrainFuck
+- should preserve the behavior of hworld.fl when translating from BrainFuck to FlufflePuff
+- should preserve the behavior of hworld.b when translating from FlufflePuff to BrainFuck
 VolatileSpec:
 Volatile
 - should run hworld.vol correctly
@@ -200,6 +203,11 @@ PrimeNumTools
 - should generate a list of prime number Ints by trial division
 - should generate a list of prime number SafeLongs by trial division
 - should generate a list of prime number SafeLongs by incremental SOE
+- should correctly identify primes numbers
+- should factor a number such that it is equal to the product of its factors
+LambdaToUnlambdaSpace:
+Lambda_Calculus => Unlambda
+- should preserve the behavior of absCountUnlambda.txt
 PATHSpec:
 PATH
 - should run hworld.path correctly
@@ -222,8 +230,8 @@ MetatapeSpec:
 Metatape
 - should run hworld.mt correctly
 - should run bitWidth.mt correctly
-Run completed in 1 minute, 55 seconds.
-Total number of tests run: 127
-Suites: completed 46, aborted 0
-Tests: succeeded 127, failed 0, canceled 0, ignored 0, pending 0
+Run completed in 2 minutes, 19 seconds.
+Total number of tests run: 131
+Suites: completed 48, aborted 0
+Tests: succeeded 131, failed 0, canceled 0, ignored 0, pending 0
 All tests passed.
diff --git a/mycologyReport.txt b/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 2 
+	That the day of the month is 3 
 	That the month is 3 
 	That the year is 2020 
-	That the time is 04 : 46 : 42 
+	That the time is 07 : 52 : 42 
 	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 520000 
-UNDEF: T after M pushed 0 and a second T, after 675 ys, pushed 12430000 
+UNDEF: S pushed 232000 
+UNDEF: T after M pushed 1000 and a second T, after 675 ys, pushed 12813000 
 GOOD: ET reflected
 
 Testing fingerprint MODE... not loaded.
diff --git a/src/main/scala/common/AbstractionEliminator.scala b/src/main/scala/common/AbstractionEliminator.scala
@@ -0,0 +1,17 @@
+package common
+
+import parsers.EsoParser
+
+import scala.util.Try
+
+abstract class AbstractionEliminator extends Transpiler{
+  val src: String = "Lambda_Calculus"
+  
+  val parser: EsoParser[Seq[Char], Expr]
+  
+  def apply(config: Config)(progRaw: String): Try[String] = parser(progRaw).toTry() map (_.toString)
+  
+  abstract class Expr{
+    def elim(c: Char): Expr
+    def uses(c: Char): Boolean}
+}
diff --git a/src/main/scala/common/PrimeNumTools.scala b/src/main/scala/common/PrimeNumTools.scala
@@ -41,8 +41,9 @@ object PrimeNumTools {
       if(n.emod(f) == 0) false
       else if(f*f >= n) true
       else pdo(f + 2)}
-    n == 2 || (n.emod(2) == 0 && pdo(3))}
+    n == 2 || n == 3 || (n > 1 && n.emod(2) == 1 && pdo(3))}
   
+  def factor(num: Int): Vector[Int] = factor(SafeLong(num))
   def factor(num: SafeLong): Vector[Int] = {
     @tailrec
     def fdo(init: SafeLong, f: SafeLong, c: Int = 0): (SafeLong, Int) = {
diff --git a/src/main/scala/common/Transpiler.scala b/src/main/scala/common/Transpiler.scala
@@ -20,4 +20,6 @@ abstract class Transpiler extends EsoObj{
       case _ => ac.mkString("\n")}
     val lines = prog.linesIterator.to(LazyList).map(_.dropWhile("\t ".contains(_)))
     ido(0, Vector(), lines)}
+  
+  override def toString: String = s"$src => $dst"
 }
diff --git a/src/main/scala/lazyk/LambdaToLazyKUnl.scala b/src/main/scala/lazyk/LambdaToLazyKUnl.scala
@@ -0,0 +1,31 @@
+package lazyk
+
+import common.AbstractionEliminator
+import parsers.{EsoParser, PartialArbitraryScanParser}
+
+object LambdaToLazyKUnl extends AbstractionEliminator{
+  val dst: String = "LazyK_Unlambda"
+  
+  val parser: EsoParser[Seq[Char], Expr] = {
+    PartialArbitraryScanParser[Char, Expr](_.headOption){
+      case (cs :+ '^' :+ c, a +: ac) => (cs, a.elim(c) +: ac)
+      case (cs :+ '`', x +: y +: ac) => (cs, AppExpr(x, y) +: ac)
+      case (cs :+ c, ac) =>
+        if(" \t\r\n".contains(c)) (cs, ac)
+        else (cs, CharExpr(c) +: ac)}
+      .withErrors}
+  
+  case class AppExpr(x: Expr, y: Expr) extends Expr {
+    def elim(c: Char): Expr =
+      if(uses(c)) AppExpr(AppExpr(CharExpr('s'), x.elim(c)), y.elim(c))
+      else AppExpr(CharExpr('k'), this)
+    def uses(c: Char): Boolean = x.uses(c) || y.uses(c)
+    override def toString: String = s"`$x$y"}
+  
+  case class CharExpr(chk: Char) extends Expr {
+    def elim(c: Char): Expr =
+      if(c == chk) CharExpr('i')
+      else AppExpr(CharExpr('k'), this)
+    def uses(c: Char): Boolean = c == chk
+    override def toString: String = chk.toString}
+}
diff --git a/src/main/scala/lazyk/LazyKAnyToCC.scala b/src/main/scala/lazyk/LazyKAnyToCC.scala
@@ -10,7 +10,9 @@ object LazyKAnyToCC extends LazyKDialectTranslator{
   
   def unapply(config: Config)(prog: String): Try[String] = {
     def mkStr(exp: Expr): String = exp match{
-      case AppExpr(e1, e2) => s"(${mkStr(e1)}${mkStr(e2)})"
+      case AppExpr(e1, e2) => e2 match{
+        case FuncExpr(_) => s"${mkStr(e1)}${mkStr(e2)}"
+        case _ => s"${mkStr(e1)}(${mkStr(e2)})"}
       case FuncExpr(fun) => fun match{
         case `scomb` => "S"
         case `kcomb` => "K"
diff --git a/src/main/scala/ui/EsoDefaults.scala b/src/main/scala/ui/EsoDefaults.scala
@@ -21,7 +21,7 @@ import scala_run.ScalaRun
 import slashes.Slashes
 import snusp.{BFToSNUSP, SNUSP}
 import thue.Thue
-import unlambda.Unlambda
+import unlambda.{LambdaToUnlambda, Unlambda}
 import volatile.Volatile
 import whitespace.{WSAssembly, WhiteSpace, WhiteSpaceToScala}
 import wierd.Wierd
@@ -101,7 +101,7 @@ object EsoDefaults extends EsoObj{
     ALPL,
     LazyBird)
   val defTransVec: Vector[Translator] = Vector[Translator](FlufflePuff, Ook, WSAssembly, GlyphoShorthand, LazyKAnyToUnl, LazyKAnyToIota, LazyKAnyToCC, LazyKAnyToJot)
-  val defGenVec: Vector[Transpiler] = Vector[Transpiler](BFToScala, BFToCPP, WhiteSpaceToScala, BFToSNUSP, BFToMetatape, BFToPrelude, BFToLazyK)
+  val defGenVec: Vector[Transpiler] = Vector[Transpiler](BFToScala, BFToCPP, WhiteSpaceToScala, BFToSNUSP, BFToMetatape, BFToPrelude, BFToLazyK, LambdaToLazyKUnl, LambdaToUnlambda)
   
   val defBoolVec: Vector[(String, Boolean, String)] = Vector[(String, Boolean, String)](
     ("log", false, "toggle detailed console logging"),
diff --git a/src/main/scala/ui/InterfaceHandlers.scala b/src/main/scala/ui/InterfaceHandlers.scala
@@ -358,7 +358,7 @@ case class ListLangsHandler(eio: EsoIOInterface = EsoConsoleInterface) extends I
           |${state.trans.values.map(t => s"- $t").toVector.sorted.mkString("\n")}
           |
           |Transpilers...
-          |${state.gens.keys.map{case (snam, dnam) => s"- $snam => $dnam"}.toVector.sorted.mkString("\n")}
+          |${state.gens.values.map(t => s"- $t").toVector.sorted.mkString("\n")}
           |""".stripMargin
     eio.println(str)
     
diff --git a/src/main/scala/unlambda/LambdaToUnlambda.scala b/src/main/scala/unlambda/LambdaToUnlambda.scala
@@ -0,0 +1,41 @@
+package unlambda
+
+import common.AbstractionEliminator
+import parsers.{EsoParser, PartialArbitraryScanParser}
+
+import scala.annotation.tailrec
+
+object LambdaToUnlambda extends AbstractionEliminator{
+  val dst: String = "Unlambda"
+  val parser: EsoParser[Seq[Char], Expr] = {
+    @tailrec
+    def cdo(src: Seq[Char], ac: Vector[Char] = Vector()): Vector[Char] = src match{
+      case a +: b +: cs if a == '.' || a == '?' => cdo(cs, ac :+ a :+ (-b).toChar)
+      case c +: cs => if(" \t\r\n".contains(c)) cdo(cs, ac) else cdo(cs, ac :+ c)
+      case _ => ac}
+    PartialArbitraryScanParser[Char, Expr](_.headOption){
+      case (cs :+ a :+ b, ac) if a == '.' || a == '?' => (cs, IOExpr(a, (-b).toChar) +: ac)
+      case (cs :+ '^' :+ c, a +: ac) => (cs, a.elim(c) +: ac)
+      case (cs :+ '`', x +: y +: ac) => (cs, AppExpr(x, y) +: ac)
+      case (cs :+ c, ac) => (cs, CharExpr(c) +: ac)}
+      .withConditioning(inp => cdo(inp))}
+  
+  case class AppExpr(x: Expr, y: Expr) extends Expr {
+    def elim(c: Char): Expr =
+      if(uses(c)) AppExpr(AppExpr(CharExpr('s'), x.elim(c)), y.elim(c))
+      else AppExpr(CharExpr('k'), AppExpr(CharExpr('d'), this))
+    def uses(c: Char): Boolean = x.uses(c) || y.uses(c)
+    override def toString: String = s"`$x$y"}
+  
+  case class CharExpr(chk: Char) extends Expr {
+    def elim(c: Char): Expr =
+      if(c == chk) CharExpr('i')
+      else AppExpr(CharExpr('k'), this)
+    def uses(c: Char): Boolean = c == chk
+    override def toString: String = chk.toString}
+  
+  case class IOExpr(op: Char, arg: Char) extends Expr {
+    def elim(c: Char): Expr = AppExpr(CharExpr('k'), AppExpr(CharExpr('d'), this))
+    def uses(c: Char): Boolean = false
+    override def toString: String = s"$op$arg"}
+}
diff --git a/src/test/scala/common/PrimeNumToolsSpec.scala b/src/test/scala/common/PrimeNumToolsSpec.scala
@@ -2,6 +2,7 @@ package common
 
 import common_test.EsoSpec
 import spire.math.SafeLong
+import spire.implicits._
 
 class PrimeNumToolsSpec extends EsoSpec{
   val primeRef: Vector[Int] = Vector(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541)
@@ -10,10 +11,25 @@ class PrimeNumToolsSpec extends EsoSpec{
   "PrimeNumTools" should "generate a list of prime number Ints by trial division" in {
     val res = PrimeNumTools.primesLazy.take(100).toVector
     assertResult(primeRef)(res)}
+  
   it should "generate a list of prime number SafeLongs by trial division" in {
     val res = PrimeNumTools.primesLazySL.take(100).toVector
     assertResult(primeRefSL)(res)}
+  
   it should "generate a list of prime number SafeLongs by incremental SOE" in {
     val res = PrimeNumTools.birdPrimes.take(100).toVector
     assertResult(primeRefSL)(res)}
+  
+  it should "correctly identify primes numbers" in {
+    val ps = LazyList.range(1, 100).filter(PrimeNumTools.isPrime)
+    val ref = PrimeNumTools.primesLazy.takeWhile(_ < 100)
+    assertResult(ref)(ps)}
+  
+  it should "factor a number such that it is equal to the product of its factors" in {
+    val primes = PrimeNumTools.primesLazy
+    val factored = LazyList.range(1, 100).map(num => (num, PrimeNumTools.factor(num)))
+    def toNum(facs: Vector[Int]): Int = facs.zip(primes).map{case (p, b) => b**p}.product
+    for((num, facs) <- factored){
+      val res = toNum(facs)
+      if(res != num) fail(s"${facs.mkString("[", ", ", "]")} = $res != $num")}}
 }
diff --git a/src/test/scala/common_test/EsoSpec.scala b/src/test/scala/common_test/EsoSpec.scala
@@ -1,6 +1,6 @@
 package common_test
 
-import common.{Config, Interpreter, Translator}
+import common.{Config, Interpreter, Translator, Transpiler}
 import org.scalatest.flatspec.AnyFlatSpec
 import ui.{EsoFileReader, EsoRunState}
 
@@ -21,6 +21,16 @@ abstract class EsoSpec extends AnyFlatSpec{
     builder ++= vec
     builder.result}
   
+  def testTranspilerAgainstProgramResult(interp: Interpreter, trans: Transpiler, prog: String, expected: String, inp: Seq[Char] = Seq(), config: Config = defaultConfig): Unit = {
+    trans(config)(prog) match{
+      case Success(res) => assertOutput(interp, res, expected, inp, config)
+      case Failure(e) => fail(s"Transpilation Failed ($e)")}}
+  def testAllTranspiledAgainstProgramResult(interp: Interpreter, trans: Transpiler, config: Config = defaultConfig)(itms: (String, String, String)*): Unit = {
+    itms match{
+      case (nam1, inp1, ref1) +: rem =>
+        trans.toString should s"preserve the behavior of $nam1" in testTranspilerAgainstProgramResult(interp, trans, grabFile(nam1), ref1, inp1.toSeq, config)
+        for((nam, inp, ref) <- rem) it should s"preserve the behavior of $nam" in testTranspilerAgainstProgramResult(interp, trans, grabFile(nam), ref, inp.toSeq, config)}}
+  
   def testTranslatorAgainstOutput(trans: Translator, rev: Boolean, prog: String, expected: String, config: Config = defaultConfig): Unit = {
     val restry = {
       if(rev) trans.unapply(config)(prog)
@@ -31,17 +41,17 @@ abstract class EsoSpec extends AnyFlatSpec{
   def testAllTranslatedAgainstOutput(trans: Translator, config: Config = defaultConfig)(itms: (String, String, Boolean)*): Unit = {
     itms match{
       case (nam1, ref1, rev1) +: rem =>
-        trans.toString should s"Preserve the behavior of $nam1 when translating from ${if(rev1) s"${trans.name} to ${trans.baseLang}" else s"${trans.baseLang} to ${trans.name}"}" in{
+        trans.toString should s"preserve the behavior of $nam1 when translating from ${if(rev1) s"${trans.name} to ${trans.baseLang}" else s"${trans.baseLang} to ${trans.name}"}" in{
           testTranslatorAgainstOutput(trans, rev1, grabFile(nam1), ref1, config)}
         for((nam, ref, rev) <- rem){
-          it should s"Preserve the behavior of $nam when translating from ${if(rev) s"${trans.name} to ${trans.baseLang}" else s"${trans.baseLang} to ${trans.name}"}" in{
+          it should s"preserve the behavior of $nam when translating from ${if(rev) s"${trans.name} to ${trans.baseLang}" else s"${trans.baseLang} to ${trans.name}"}" in{
             testTranslatorAgainstOutput(trans, rev, grabFile(nam), ref, config)}}}}
   def testTranslatorAgainstProgramResult(intp: Interpreter, trans: Translator, rev: Boolean, prog: String, expected: String, inp: Seq[Char] = Seq(), canBeSame: Boolean = false, config: Config = defaultConfig): Unit = {
     val restry = {
       if(rev) trans.unapply(config)(prog)
       else trans(config)(prog)}
     restry match{
-      case Success(res) if canBeSame || res != prog => assertOutput(intp, res, expected, config=config)
+      case Success(res) if canBeSame || res != prog => assertOutput(intp, res, expected, inp, config)
       case Success(_) => fail("Output Identical")
       case Failure(e) => fail(s"Translation Failed ($e)")}}
   def testAllTranslatedAgainstProgramResult(intp: Interpreter, trans: Translator, canBeSame: Boolean = false, config: Config = defaultConfig)(itms: (String, String, String, Boolean)*): Unit = {
diff --git a/src/test/scala/lazyk/LambdaToLazyKUnlSpec.scala b/src/test/scala/lazyk/LambdaToLazyKUnlSpec.scala
@@ -0,0 +1,8 @@
+package lazyk
+
+import common_test.EsoSpec
+
+class LambdaToLazyKUnlSpec extends EsoSpec{
+  testAllTranspiledAgainstProgramResult(LazyK, LambdaToLazyKUnl)(
+    ("absSpaceLazyK.txt", "", " "))
+}
diff --git a/src/test/scala/unlambda/LambdaToUnlambdaSpace.scala b/src/test/scala/unlambda/LambdaToUnlambdaSpace.scala
@@ -0,0 +1,8 @@
+package unlambda
+
+import common_test.EsoSpec
+
+class LambdaToUnlambdaSpace extends EsoSpec{
+  testAllTranspiledAgainstProgramResult(Unlambda, LambdaToUnlambda)(
+    ("absCountUnlambda.txt", "", "1\n22\n333"))
+}
diff --git a/testResources/absCountUnlambda.txt b/testResources/absCountUnlambda.txt
@@ -0,0 +1,4 @@
+```^a^b^c``abc
+`r``^f^x`fx.1i
+`r``^f^x`f`fx.2i
+``^f^x`f`f`fx.3i
diff --git a/testResources/absSpaceLazyK.txt b/testResources/absSpaceLazyK.txt
@@ -0,0 +1 @@
+^u^g``g^f^x`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`f`fx`^n`nn`^n`nn^g^x`g`gx

Original file line number	Diff line number	Diff line change
`@@ -20,4 +20,6 @@ abstract class Transpiler extends EsoObj{`
`20`	`20`	`case _ => ac.mkString("\n")}`
`21`	`21`	`val lines = prog.linesIterator.to(LazyList).map(_.dropWhile("\t ".contains(_)))`
`22`	`22`	`ido(0, Vector(), lines)}`
	`23`	`+`
	`24`	`+ override def toString: String = s"$src => $dst"`
`23`	`25`	`}`