diff --git a/.github/workflows/test_and_release.yml b/.github/workflows/test_and_release.yml new file mode 100644 index 00000000..08b06209 --- /dev/null +++ b/.github/workflows/test_and_release.yml @@ -0,0 +1,46 @@ +name: Test code, update coverage, and release main branch + +on: [ push, pull_request ] + +jobs: + release: + runs-on: ubuntu-latest + needs: [ ] + steps: + - uses: actions/checkout@v4.2.2 + - name: Check if we are head of main + id: check_head_of_main + run: | + git fetch origin main && + MAIN=`git rev-parse origin/main` && + echo "::set-output name=head_of_main::$MAIN" && + CURRENT=`git rev-list -n 1 ${{ github.ref }} || echo "NOT_MAIN"` && + echo "::set-output name=current_job_ref::$CURRENT" + - name: Set up JDK + if: steps.check_head_of_main.outputs.head_of_main == steps.check_head_of_main.outputs.current_job_ref + uses: actions/setup-java@v4 + with: + distribution: temurin + java-version: 21 + - name: Set up SBT + if: steps.check_head_of_master.outputs.head_of_main == steps.check_head_of_main.outputs.current_job_ref + uses: sbt/setup-sbt@v1.1.16 + with: + sbt-runner-version: 1.10.11 + - name: Build and release + if: steps.check_head_of_master.outputs.head_of_main == steps.check_head_of_main.outputs.current_job_ref + env: + SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }} + SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }} + SONA_USER: ${{ secrets.SONATYPE_USERNAME }} + SONA_PASS: ${{ secrets.SONATYPE_PASSWORD }} + PGP_SECRET: ${{ secrets.PGP_SECRET }} + PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }} + PGP_KEY_HEX: ${{ secrets.PGP_KEY_HEX }} + CI: github + run: | + git fetch --prune --unshallow --tags && + export GPG_TTY=$(tty) && + echo $PGP_SECRET | base64 -d | gpg --passphrase=$PGP_PASSPHRASE --yes --batch --pinentry-mode loopback --import && + export PATH=`pwd`/.github/bin:$PATH && + sbt cogen/ciReleaseTagNextVersion cogen/ciReleaseSonatype diff --git a/January-2026-ToDo.txt b/January-2026-ToDo.txt new file mode 100644 index 00000000..229e275e --- /dev/null +++ b/January-2026-ToDo.txt @@ -0,0 +1,2 @@ +1. Visitor / M5 yields "key not found: Tree" + diff --git a/README.md b/README.md index c0bcdd80..c8fecc55 100644 --- a/README.md +++ b/README.md @@ -313,12 +313,12 @@ family and are created using this same initial execution. # Dependencies -EPCoGen is compiled with Scala version 2.12.17. +EPCoGen is compiled with Scala 3.6.4 version. -All examples validated on Linux and Windows, using [sbt 1.7.2](https://www.scala-sbt.org/download#previous-releases) +All examples validated on Linux and Windows, using [sbt 1.10.11](https://www.scala-sbt.org/download#previous-releases) , Scala version 2.12.17 and [Java 11 (OpenJDK)](https://openjdk.org/projects/jdk/11/). -Java code is generated using [JavaParser](https://github.com/javaparser/javaparser) version 3.19.0. +Java code is generated using [JavaParser](https://github.com/javaparser/javaparser) version 3.26.4. All JUnit tests are compiled using [JUnit 4.12](https://junit.org/junit4/) and Java compiler is directed to compile only assuming Java 1.8 compatibility. @@ -326,7 +326,7 @@ compile only assuming Java 1.8 compatibility. The images above were generated using [GraphViz online](https://dreampuf.github.io/GraphvizOnline) based on output generated by our [GraphViz](core/src/main/scala/org/combinators/ep/domain/GraphViz.scala) code. -All generated Scala code is compiled using Scala version 3.3.3 and version +All generated Scala code is compiled using Scala version 3.6.4 and version 3.2.19 of the [Scalactic testing framework](https://www.scalatest.org/) Python scripts require Python 3. Only the `scipy` package needs to be installed. diff --git a/TECHNICAL.txt b/TECHNICAL.txt index 67d8c448..9b9e80f7 100644 --- a/TECHNICAL.txt +++ b/TECHNICAL.txt @@ -1,41 +1,95 @@ +Codebase validated to work with + + scalaVersion := "3.6.4" + When you have a fresh clone of the git repository, enter the command `sbt compile` in the top-level directory to compile EpCoGen. sbt will properly install all necessary software libraries. -We have tested with sbt versions of 1.7.1, 1.9.8, and 1.10.7. +We have tested with sbt versions of 1.7.1, 1.9.8, 1.10.7, and 1.10.11. + +We have tested with Java JDK 18. If your Java version is too advanced for the sbt, you may need to add the following to the build.st file to lower the associated Java version. - javacOptions ++= Seq("-source", "11", "-target", "11"), + javacOptions ++= Seq("-source", "11", "-target", "11") And then you can install an openJDK version of Java 11 and use it by setting JAVA_HOME -properly and/or configuring PATH variable appropriately. +properly and/or configuring PATH variable appropriately. Grab the appropriate JDK 11 +from https://www.openlogic.com/openjdk-downloads =================================== Examples to run =================================== -Sample commands to run. The first column shows the time it was launched, so to generate all -evolution stages for all approaches on a Linux machine took just under an hour. And the -compiling process for all code took just about three hours. - -15:17 sbt language-java/run -16:08 cd target/ -16:09 cd ep-java -16:11 python3 ../../scripts/compare.py ../../scripts/systems/system-main.json >> REPORT -16:12 python3 ../../scripts/compile.py -19:08 python3 ../../scripts/process.py > STATISTICS -19:09 cd .. -19:11 sbt "helloWorld/runMain org.combinators.fibonacci.FibonacciWithLucasScalaDirectToDiskMain" -19:13 cd target/fib -19:13 cd scala/ -19:13 sbt test +Sample commands to run. The first column shows the time to execute, so to generate all +evolution stages for all approaches on a Linux machine took 22 minutes. The greatest +cost is compiling everything. To compile the main example took about 2 hours since there +are 27 evolutionary stages in the example. + +Time Command +00:02 sbt compile +00:22 sbt language-java/run + cd target/ep-java +00:01 python3 ../../scripts/compare.py ../../scripts/systems/system-main.json >> REPORT +02:10 python3 ../../scripts/compile.py + +00:01 python3 ../../scripts/process.py > STATISTICS + cd ../.. + +--------------------------------- +Java Generation --------------------------------- +The above generates all subdirectories that can now be compiled: + +* D1D2 (to just generated this, execute `sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllD1D2"`) + + cd target/ep-java-d1d2 + python3 ../../scripts/compare.py ../../scripts/systems/system-d1d2.json >> REPORT + python3 ../../scripts/compile.py + python3 ../../scripts/process.py > STATISTICS + +* Main (to just generated this, execute `sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllMain"`) + + cd target/ep-java + python3 ../../scripts/compare.py ../../scripts/systems/system-main.json >> REPORT + python3 ../../scripts/compile.py + python3 ../../scripts/process.py > STATISTICS + +* Merging (to just generated this, execute `sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllMerging"`) + + cd target/ep-java-merging + python3 ../../scripts/compare.py ../../scripts/systems/system-merging.json >> REPORT + python3 ../../scripts/compile.py + python3 ../../scripts/process.py > STATISTICS + +* Extended (to just generated this, execute `sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllExtended"`) + + cd target/ep-java-extended + python3 ../../scripts/compare.py ../../scripts/systems/system-extended.json >> REPORT + python3 ../../scripts/compile.py + python3 ../../scripts/process.py > STATISTICS + +* Third Alternate (to just generated this, execute `sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllThirdAlternate"`) + + cd target/ep-java-third-alternate + python3 ../../scripts/compare.py ../../scripts/systems/system-third-alternate.json >> REPORT + python3 ../../scripts/compile.py + python3 ../../scripts/process.py > STATISTICS + +* System J (to just generated this, execute `sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllJ"`) + + cd target/ep-java-j + python3 ../../scripts/compare.py ../../scripts/systems/system-j.json >> REPORT + python3 ../../scripts/compile.py + python3 ../../scripts/process.py > STATISTICS + + When generating the full Java implementations for all approaches and all evolution stages, -there are 19,842 Java files containing 513,094 total lines of code. +there are 17,469 Java files containing 432,215 total lines of code. Using the CLOC utility, a more accurate picture appears. Of these only 3890 are truly unique files. The reason? Because the Expression Problem shows how to extend a system without @@ -43,22 +97,39 @@ modifying already created code, so it makes perfect sense that 80% of the code i % $CLOC --csv `find . -name "*.java"` - 19842 text files. - 3890 unique files. - 15952 files ignored. + 17429 text files. + 3279 unique files. + 14150 files ignored. -files,language,blank,comment,code,"github.com/AlDanial/cloc v 1.86 T=17.31 s (224.7 files/s, 7917.7 lines/s)" -3890,Java,27755,4,109292 -3890,SUM,27755,4,109292 +files,language,blank,comment,code,"github.com/AlDanial/cloc v 1.86 T=21.67 s (151.3 files/s, 4895.7 lines/s)" +3279,Java,22368,4,83739 +3279,SUM,22368,4,83739 -cloc reports 109,292 lines of code. +cloc reports 83,739 lines of code. Now run and turn off the uniqueness check: % $CLOC --csv `find . -name "*.java"` --skip-uniqueness -19842,Java,117328,516,395250 +17429,Java,101632,420,327068 This reveals that 395,250 lines of Java code were generated. +--------------------------------- +ScalaGeneration +--------------------------------- +sbt "language-newScala/runMain org.combinators.ep.language.scala.codegen.GenerateAllJ" +sbt "language-newScala/runMain org.combinators.ep.language.scala.codegen.GenerateAllD1D2" +sbt "language-newScala/runMain org.combinators.ep.language.scala.codegen.GenerateAllMain" +sbt "language-newScala/runMain org.combinators.ep.language.scala.codegen.GenerateAllMerging" +sbt "language-newScala/runMain org.combinators.ep.language.scala.codegen.GenerateAllExtended" + +% $CLOC --csv `find ep-scala -name "*.scala"` `find ep-scala-d1d2 -name "*.scala"` `find ep-scala-extended -name "*.scala"` `find ep-scala-j -name "*.scala"` `find ep-scala-merging -name "*.scala"` + + 16770 text files. + 12217 unique files. + 4553 files ignored. +files,language,blank,comment,code,"github.com/AlDanial/cloc v 1.86 T=31.21 s (391.5 files/s, 14591.1 lines/s)" +12217,Scala,242004,0,213356 +12217,SUM,242004,0,213356 diff --git a/TODO.txt b/TODO.txt index 56772242..d5dd76c3 100644 --- a/TODO.txt +++ b/TODO.txt @@ -1,12 +1,10 @@ -1. Generated test cases often exceed length allowed to method declarations. +Generated test cases often exceed length allowed to method declarations. a. As a stop-gap measure, these methods are arbitrarily split up, which means that the visitorSideEffect has test cases that do not compile because of variables defined for the visitor in one method but used in the other method. -2. Functional -- continue progress from before - -3. +Functional -- continue progress from before Scala-InBetween could add 'trait' capability and that could then be exposed as an option. This is high-level change and not @@ -14,27 +12,6 @@ object-oriented per se. Add exceptions to newScala -Make CoGen stand alone - -Note that Java equality in methods uses the .equals() which is a problem with primitive types. Thoughts? - Trees that grow -============================ - -Notes: A1M3 for coco needs a full Exp and Factory. Why? Because otherwise merge accessing finalized instances from A1 are incompatible with -the finalized instances from M3. Similar argument for M3W1 and even A1M3I2 - - ifEqExpr <- ffiEquals.equalityCapabilities.areEqual(expType, expValue, zero) - where expType is expType <- toTargetLanguageType(TypeRep.Double) - -It wasn't working because I had mistakenly used a type for "ep.Exp[FT]" - -ALgebra had to go back to its own "dataTypeCasesWithNewOperations" for some reason. - -So Coco, Trivially and Algebra all have slightly different results and it REALLY makes me curious -as to why - -============================ - Runtime Dispatch FAILS whenever pass in a model. if we can fix this, then I can better integrate with OO code. \ No newline at end of file diff --git a/core/src/main/scala/org/combinators/ep/approach/functional/Traditional.scala b/approach/src/main/scala/org/combinators/ep/approach/functional/Traditional.scala similarity index 85% rename from core/src/main/scala/org/combinators/ep/approach/functional/Traditional.scala rename to approach/src/main/scala/org/combinators/ep/approach/functional/Traditional.scala index d5ea0d6d..0aafeff8 100644 --- a/core/src/main/scala/org/combinators/ep/approach/functional/Traditional.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/functional/Traditional.scala @@ -1,15 +1,17 @@ package org.combinators.ep.approach.functional /*DI:LI:AD*/ import org.combinators.ep.domain.GenericModel -import org.combinators.ep.generator.{AbstractSyntax, ApproachImplementationProvider, Command, EvolutionImplementationProvider, NameProvider, Understands} -import org.combinators.ep.generator.paradigm.control.{ConstructorPattern, Functional => FunControl} -import Command.{Generator, _} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import org.combinators.cogen.{AbstractSyntax, Command, NameProvider, TypeRep, Understands} +import Command.Generator import cats.implicits._ -import org.combinators.ep.domain.abstractions.{DataType, DataTypeCase, Operation, Parameter, TypeRep} +import org.combinators.cogen.paradigm.{AnyParadigm, FindType, Functional} +import org.combinators.ep.domain.abstractions.{DataType, DataTypeCase, DomainTpeRep, Operation, Parameter} import org.combinators.ep.generator.communication.{ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, FindType, Functional} import AnyParadigm.syntax._ -import org.combinators.ep.generator.paradigm.control.Functional.WithBase +import org.combinators.cogen.paradigm.control.{ConstructorPattern, Functional as FunControl} +import org.combinators.cogen.paradigm.control.Functional.WithBase +import org.combinators.ep.domain.extensions._ trait Traditional extends ApproachImplementationProvider { val functional: Functional.WithBase[paradigm.type] @@ -34,7 +36,7 @@ trait Traditional extends ApproachImplementationProvider { import paradigm.methodBodyCapabilities._ import functional.methodBodyCapabilities._ for { - rt <- toTargetLanguageType(TypeRep.DataType(baseTpe)) + rt <- toTargetLanguageType(DomainTpeRep.DataType(baseTpe)) _ <- resolveAndAddImport(rt) res <- instantiateType(rt, names.mangle(names.conceptNameOf(tpeCase)), args) } yield res @@ -104,7 +106,7 @@ trait Traditional extends ApproachImplementationProvider { } for { - params <- forEach (Parameter(names.instanceNameOf(tpe), TypeRep.DataType(tpe)) +: op.parameters) { param: Parameter => + params <- forEach (Parameter(names.instanceNameOf(tpe), DomainTpeRep.DataType(tpe)) +: op.parameters) { (param: Parameter) => for { pt <- toTargetLanguageType(param.tpe) _ <- resolveAndAddImport(pt) @@ -116,7 +118,7 @@ trait Traditional extends ApproachImplementationProvider { _ <- resolveAndAddImport(returnType) _ <- setReturnType(returnType) args <- getArguments() - onTpe <- toTargetLanguageType(TypeRep.DataType(tpe)) + onTpe <- toTargetLanguageType(DomainTpeRep.DataType(tpe)) result <- { val matchGen = makeCases(tpe, cases, op, args.head._3, args.tail, domainSpecific)(_, _) patternMatch( @@ -153,7 +155,7 @@ trait Traditional extends ApproachImplementationProvider { import functional.projectCapabilities._ import functional.methodBodyCapabilities._ // Needed below import functional.typeCapabilities._ // Needed below - val dtpeRep = TypeRep.DataType(domain.baseDataType) + val dtpeRep = DomainTpeRep.DataType(domain.baseDataType) for { _ <- addTypeLookupForMethods(dtpeRep, domainTypeLookup(domain.baseDataType)) _ <- addTypeLookupForTypes(dtpeRep, domainTypeLookup(domain.baseDataType)) @@ -182,11 +184,13 @@ object Traditional { (base: P) (nameProvider: NameProvider[base.syntax.Name], fun: Functional.WithBase[base.type], - funControl: FunControl.WithBase[base.MethodBodyContext, base.type]): Traditional.WithParadigm[base.type] = - new Traditional { - override val paradigm: base.type = base - override val names: NameProvider[base.syntax.Name] = nameProvider - override val functional: Functional.WithBase[paradigm.type] = fun - override val functionalControl: WithBase[paradigm.MethodBodyContext, paradigm.type] = funControl - } + funControl: FunControl.WithBase[base.MethodBodyContext, base.type]): Traditional.WithParadigm[base.type] = { + case class Trad( + override val paradigm: base.type, + override val names: NameProvider[base.syntax.Name])( + override val functional: Functional.WithBase[paradigm.type], + override val functionalControl: WithBase[paradigm.MethodBodyContext, paradigm.type] + ) extends Traditional + Trad(base, nameProvider)(fun, funControl) + } } diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala similarity index 97% rename from core/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala index 3f629e4c..aeb92ed3 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala @@ -1,11 +1,14 @@ package org.combinators.ep.approach.oo /*DI:LI:AD*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TestCase, TypeRep} +import org.combinators.cogen.{TestCase, TypeRep, Command, AbstractSyntax, NameProvider, Understands} +import Command.Generator +import org.combinators.cogen.paradigm.{AddImport, AddTypeLookup, AnyParadigm, Apply, FindClass, Generics, ObjectOriented, ParametricPolymorphism, ResolveImport} +import org.combinators.ep.domain.abstractions.{DataTypeCase, DomainTpeRep, Operation} import org.combinators.ep.domain.{GenericModel, abstractions} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.{AbstractSyntax, Command, EvolutionImplementationProvider, NameProvider, TestImplementationProvider, Understands, communication} -import org.combinators.ep.generator.paradigm.{AddImport, AnyParadigm, Apply, FindClass, Generics, ObjectOriented, ParametricPolymorphism, ResolveImport, AddTypeLookup} +import org.combinators.ep.domain.extensions._ +import org.combinators.cogen.paradigm.AnyParadigm.syntax.forEach +import org.combinators.ep.generator.{EvolutionImplementationProvider, TestImplementationProvider, communication} +import org.combinators.ep.generator._ trait CoCoClean extends SharedOO { val paradigm: AnyParadigm @@ -410,8 +413,7 @@ trait CoCoClean extends SharedOO { } else { None } - - result + result } } @@ -531,7 +533,7 @@ trait CoCoClean extends SharedOO { // Add methods for new operations // In Methods we use the least specific type (ep.Exp) to refer to the domain base type. - _ <- addTypeLookupForMethods(TypeRep.DataType(domain.baseDataType), leastSpecialBaseInterfaceType(domain, finalizedType)( + _ <- addTypeLookupForMethods(DomainTpeRep.DataType(domain.baseDataType), leastSpecialBaseInterfaceType(domain, finalizedType)( canFindClass = ooParadigm.methodBodyCapabilities.canFindClassInMethod, canResolveImport = paradigm.methodBodyCapabilities.canResolveImportInMethod, canAddImport = paradigm.methodBodyCapabilities.canAddImportInMethodBody, @@ -878,7 +880,7 @@ trait CoCoClean extends SharedOO { import paradigm.methodBodyCapabilities._ import ooParadigm.constructorCapabilities._ import ooParadigm.methodBodyCapabilities._ - val dtpeRep = TypeRep.DataType(model.baseDataType) + val dtpeRep = DomainTpeRep.DataType(model.baseDataType) def baseInterfaceType[Context](implicit canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], @@ -982,12 +984,14 @@ object CoCoClean { oo: ObjectOriented.WithBase[base.type], params: ParametricPolymorphism.WithBase[base.type] ) - (generics: Generics.WithBase[base.type, oo.type, params.type]): CoCoClean.WithParadigm[base.type] = - new CoCoClean { - val paradigm: base.type = base - val ooParadigm: oo.type = oo - val polymorphics: params.type = params - val genericsParadigm: generics.type = generics - val names: NameProvider[paradigm.syntax.Name] = nameProvider - } + (generics: Generics.WithBase[base.type, oo.type, params.type]): CoCoClean.WithParadigm[base.type] = { + case class CCC( + override val paradigm: base.type)( + override val ooParadigm: oo.type, + override val polymorphics: params.type, + override val names: NameProvider[paradigm.syntax.Name])( + override val genericsParadigm: generics.type + ) extends CoCoClean + CCC(base)(oo, params, nameProvider)(generics) + } } diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala similarity index 56% rename from core/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala index 5c71376f..5695d559 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala @@ -1,27 +1,30 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ +package org.combinators.ep.approach.oo +/*DI:LI:AD*/ +import org.combinators.cogen.{TestCase, TypeRep, Command, NameProvider, AbstractSyntax, Understands} +import Command.Generator +import org.combinators.cogen.paradigm.{AddImport, AnyParadigm, FindClass, Generics, ObjectOriented, ParametricPolymorphism, ResolveImport} +import org.combinators.cogen.paradigm.AnyParadigm.syntax._ import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions._ +import org.combinators.ep.domain.extensions._ import org.combinators.ep.generator._ import org.combinators.ep.generator.communication._ -import org.combinators.ep.generator.paradigm._ -import Command._ -import AnyParadigm.syntax._ /** - * Synthesizing OO and Functional Design to promote Reuse - * Shriram Krishnamurthi, Matthias Felleisen, Daniel Friedman - * https://dl.acm.org/citation.cfm?id=679709 - * - * https://stackoverflow.com/questions/55501899/exception-in-intellijs-sbt-console-not-found-value-ideaport-ideaport-in-globa - * problem with sbt... - * - * Original paper had no advice on merge case, so following is missing from k2j6 - * - public ep.j4.IsPower makeIsPower(Exp left, Exp right) { - return new IsPower(left, right); - } - */ + * Synthesizing OO and Functional Design to promote Reuse + * Shriram Krishnamurthi, Matthias Felleisen, Daniel Friedman + * https://dl.acm.org/citation.cfm?id=679709 + * + * https://stackoverflow.com/questions/55501899/exception-in-intellijs-sbt-console-not-found-value-ideaport-ideaport-in-globa + * problem with sbt... + * + * Original paper had no advice on merge case, so following is missing from k2j6 + * + * public ep.j4.IsPower makeIsPower(Exp left, Exp right) { + * return new IsPower(left, right); + * } + */ trait ExtensibleVisitor extends SharedOO with OperationAsClass { val ooParadigm: ObjectOriented.WithBase[paradigm.type] val polymorphics: ParametricPolymorphism.WithBase[paradigm.type] @@ -35,27 +38,28 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { val makePrefix = "make" /** - * Standard factory name for an operation. - * - * @param op operation for which a factory is desired. - * @return - */ - def name(op:Operation) : Name = { + * Standard factory name for an operation. + * + * @param op operation for which a factory is desired. + * @return + */ + def name(op: Operation): Name = { names.addPrefix(makePrefix, names.mangle(names.conceptNameOf(op))) } /** - * {{{ - * public FACTORYNAME () { - * return new TYPENAME(); - * } - * }}} - * @param model last model. - * @param op operation that needs to be constructed - * @param typeName fully qualified class to be constructed - * @return - */ - def create(model:GenericModel, op:Operation, shouldOverride: Boolean, typeName:Seq[Name]): Generator[ClassContext, Unit] = { + * {{{ + * public FACTORYNAME () { + * return new TYPENAME(); + * } + * }}} + * + * @param model last model. + * @param op operation that needs to be constructed + * @param typeName fully qualified class to be constructed + * @return + */ + def create(model: GenericModel, op: Operation, shouldOverride: Boolean, typeName: Seq[Name]): Generator[ClassContext, Unit] = { import ooParadigm.classCapabilities._ for { // These must be PUBLIC to allow overriding to occur. Another alternative is to make them protected, but this @@ -65,15 +69,15 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } } - object visitor { - val accept: Name = names.mangle("accept") - val visit: Name = names.mangle("visit") - val visitorClass: Name = names.mangle("Visitor") - val visitorParameter: String = "v" - val expParameter: String = "exp" - val visitTypeParameter: String = "R" + object visitor { + val accept: Name = names.mangle("accept") + val visit: Name = names.mangle("visit") + val visitorClass: Name = names.mangle("Visitor") + val visitorParameter: String = "v" + val expParameter: String = "exp" + val visitTypeParameter: String = "R" - /** + /** * A visitor that returns values can have a type parameter that specifies the type of the value returned. * * In Java, for example, the following is an accept method that takes a type parameter R. @@ -81,33 +85,34 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { * {{{ * public abstract R accept(Visitor v); * }}} + * * @return */ - def makeAcceptSignatureWithType(): Generator[MethodBodyContext, Unit] = { - import paradigm.methodBodyCapabilities.{toTargetLanguageType => _, _} - import polymorphics.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - - for { - // R by itself, since not extending any other type parameter (hence Skip) - visitTyParam <- freshName(names.mangle(visitTypeParameter)) - _ <- addTypeParameter(visitTyParam, Command.skip) - - // this returns mangled visitTypeParameter name and gets list of all type parameters, for which there is only one, so we get head - args <- getTypeArguments() - _ <- setReturnType(args.head) - - // identify Visitor - visitorClassType <- findClass(visitorClass) - _ <- resolveAndAddImport(visitorClassType) - visitorType <- applyType (visitorClassType, args) - - visitParam <- freshName(names.mangle(visitorParameter)) - _ <- setParameters(Seq((visitParam, visitorType))) // a pair (name,type) of only one sequence - } yield () - } - - /** + def makeAcceptSignatureWithType(): Generator[MethodBodyContext, Unit] = { + import paradigm.methodBodyCapabilities.{toTargetLanguageType => _, _} + import polymorphics.methodBodyCapabilities._ + import ooParadigm.methodBodyCapabilities._ + + for { + // R by itself, since not extending any other type parameter (hence Skip) + visitTyParam <- freshName(names.mangle(visitTypeParameter)) + _ <- addTypeParameter(visitTyParam, Command.skip) + + // this returns mangled visitTypeParameter name and gets list of all type parameters, for which there is only one, so we get head + args <- getTypeArguments() + _ <- setReturnType(args.head) + + // identify Visitor + visitorClassType <- findClass(visitorClass) + _ <- resolveAndAddImport(visitorClassType) + visitorType <- applyType(visitorClassType, args) + + visitParam <- freshName(names.mangle(visitorParameter)) + _ <- setParameters(Seq((visitParam, visitorType))) // a pair (name,type) of only one sequence + } yield () + } + + /** * Define the base class for Exp which must contain the accept method as an abstract method. * * {{{ @@ -116,25 +121,25 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { * } * }}} * - * @param tpe data type case whose class needs to be generated + * @param tpe data type case whose class needs to be generated * @return */ - def makeBase(tpe: DataType): Generator[ProjectContext, Unit] = { - import ooParadigm.projectCapabilities._ - - val makeClass: Generator[ClassContext, Unit] = { - import ooParadigm.classCapabilities._ - for { - _ <- setAbstract() - _ <- addAbstractMethod(accept, makeAcceptSignatureWithType()) - } yield () - } - - // adds the 'Exp' class, with a single accept method - addClassToProject( makeClass, names.mangle(names.conceptNameOf(tpe))) - } - - /** + def makeBase(tpe: DataType): Generator[ProjectContext, Unit] = { + import ooParadigm.projectCapabilities._ + + val makeClass: Generator[ClassContext, Unit] = { + import ooParadigm.classCapabilities._ + for { + _ <- setAbstract() + _ <- addAbstractMethod(accept, makeAcceptSignatureWithType()) + } yield () + } + + // adds the 'Exp' class, with a single accept method + addClassToProject(makeClass, names.mangle(names.conceptNameOf(tpe))) + } + + /** * {{{ * public class Add extends Exp { * public Add(Exp left, Exp right) { @@ -150,52 +155,53 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { * } * }}} * - * Make sure to register whenever you make the class + * Make sure to register whenever you make the class */ - def makeDerived(parentType: DataType, tpeCase: DataTypeCase, model: GenericModel): Generator[ProjectContext, Unit] = { - import ooParadigm.projectCapabilities._ - val makeClass: Generator[ClassContext, Unit] = { - import ooParadigm.classCapabilities._ - for { - parent <- toTargetLanguageType(TypeRep.DataType(parentType)) - _ <- resolveAndAddImport(parent) - _ <- addParent(parent) - _ <- forEach (tpeCase.attributes) { att => makeField(att) } - _ <- addConstructor(makeConstructor(tpeCase)) - _ <- forEach (tpeCase.attributes) { att => makeGetter(att) } - - // this is potentially different with extensible visitor - _ <- makeAcceptImplementation(model) - } yield () - } - - addClassToProject(makeClass, dataTypeClassName(model, tpeCase) : _ *) - } - - /** + def makeDerived(parentType: DataType, tpeCase: DataTypeCase, model: GenericModel): Generator[ProjectContext, Unit] = { + import ooParadigm.projectCapabilities._ + val makeClass: Generator[ClassContext, Unit] = { + import ooParadigm.classCapabilities._ + for { + parent <- toTargetLanguageType(DomainTpeRep.DataType(parentType)) + _ <- resolveAndAddImport(parent) + _ <- addParent(parent) + _ <- forEach(tpeCase.attributes) { att => makeField(att) } + _ <- addConstructor(makeConstructor(tpeCase)) + _ <- forEach(tpeCase.attributes) { att => makeGetter(att) } + + // this is potentially different with extensible visitor + _ <- makeAcceptImplementation(model) + } yield () + } + + addClassToProject(makeClass, dataTypeClassName(model, tpeCase) *) + } + + /** * Creates the signature for the 'abstract R visit(DataType exp)' method which still has no body, and can * thus become an abstract interface declaration or form the basis for an implementation. * * {{{ * public R visit(Sub exp); * }}} + * * @return */ - def makeVisitSignature(tpe:DataTypeCase, visitResultType: Type): Generator[MethodBodyContext, Unit] = { - import paradigm.methodBodyCapabilities.{toTargetLanguageType => _, _} - import polymorphics.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - - for { - _ <- setReturnType(visitResultType) - visitedClassType <- findClass(names.mangle(names.conceptNameOf(tpe))) - _ <- resolveAndAddImport(visitedClassType) - visitParamName <- freshName(names.mangle(expParameter)) - _ <- setParameters(Seq((visitParamName, visitedClassType))) // a pair (name,type) of only one sequence - } yield () - } - - /** Visitor requires an abstract base class as follows, integrating all types: + def makeVisitSignature(tpe: DataTypeCase, visitResultType: Type): Generator[MethodBodyContext, Unit] = { + import paradigm.methodBodyCapabilities.{toTargetLanguageType => _, _} + import polymorphics.methodBodyCapabilities._ + import ooParadigm.methodBodyCapabilities._ + + for { + _ <- setReturnType(visitResultType) + visitedClassType <- findClass(names.mangle(names.conceptNameOf(tpe))) + _ <- resolveAndAddImport(visitedClassType) + visitParamName <- freshName(names.mangle(expParameter)) + _ <- setParameters(Seq((visitParamName, visitedClassType))) // a pair (name,type) of only one sequence + } yield () + } + + /** Visitor requires an abstract base class as follows, integrating all types: * {{{ * public abstract class Visitor { * public abstract R visit(Sub exp); @@ -204,63 +210,64 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { * } * }}} * - * @param allTypes the flattened types in the model, for which Visitor has a single method for each type. + * @param allTypes the flattened types in the model, for which Visitor has a single method for each type. * @return */ - def makeVisitorInterface(allTypes:Seq[DataTypeCase]): Generator[ClassContext, Unit] = { - import ooParadigm.classCapabilities._ - import genericsParadigm.classCapabilities._ - - for { - _ <- setInterface() - visitTyParam <- freshName(names.mangle(visitTypeParameter)) - _ <- addTypeParameter(visitTyParam, Command.skip) // R by itself, since not extending any other type parameter (hence Skip) - visitResultType <- getTypeArguments().map(_.head) - _ <- forEach (allTypes) { tpe => addAbstractMethod(visit, makeVisitSignature(tpe, visitResultType)) } - } yield () - } - - /** - * Constructor for an operation which MAY have parameters - * @param op operation for which a constructor is needed - * @return - */ - def makeOperationConstructor(op: Operation, parent:Option[Type]): Generator[ConstructorContext, Unit] = { - import constructorCapabilities._ - for { - params <- forEach (op.parameters) { param => - for { - paramTy <- toTargetLanguageType(param.tpe) - _ <- resolveAndAddImport(paramTy) - pName <- freshName(names.mangle(param.name)) - } yield (pName, paramTy) - } - _ <- setParameters(params) - args <- getArguments() - _ <- if (parent.isEmpty) { - forEach(op.parameters.zip(args)) { case (param, (_, _, arg)) => - initializeField(names.mangle(param.name), arg) - } - } else { - initializeParent(parent.get, args.map(p => p._3)) - } - } yield () - - } - } + def makeVisitorInterface(allTypes: Seq[DataTypeCase]): Generator[ClassContext, Unit] = { + import ooParadigm.classCapabilities._ + import genericsParadigm.classCapabilities._ + + for { + _ <- setInterface() + visitTyParam <- freshName(names.mangle(visitTypeParameter)) + _ <- addTypeParameter(visitTyParam, Command.skip) // R by itself, since not extending any other type parameter (hence Skip) + visitResultType <- getTypeArguments().map(_.head) + _ <- forEach(allTypes) { tpe => addAbstractMethod(visit, makeVisitSignature(tpe, visitResultType)) } + } yield () + } + + /** + * Constructor for an operation which MAY have parameters + * + * @param op operation for which a constructor is needed + * @return + */ + def makeOperationConstructor(op: Operation, parent: Option[Type]): Generator[ConstructorContext, Unit] = { + import constructorCapabilities._ + for { + params <- forEach(op.parameters) { param => + for { + paramTy <- toTargetLanguageType(param.tpe) + _ <- resolveAndAddImport(paramTy) + pName <- freshName(names.mangle(param.name)) + } yield (pName, paramTy) + } + _ <- setParameters(params) + args <- getArguments() + _ <- if (parent.isEmpty) { + forEach(op.parameters.zip(args)) { case (param, (_, _, arg)) => + initializeField(names.mangle(param.name), arg) + } + } else { + initializeParent(parent.get, args.map(p => p._3)) + } + } yield () + + } + } /** Before instantiate is called, use this to register class where type is placed. */ case class OnlyDataTypeCase(tpeCase: DataTypeCase) extends TypeRep /** Produces, for example, Some(EvalDivdMultNeg). - * - * Either (1) the operation is defined in the current model and so you don't need to append class name, but can - * simply reply on past datatypes; or (2) concatenate and find recent one - * - * Compute the name for the visitor implementation of the given model and operation, if an implementation - * is required. - */ - def visitorClassName(model: GenericModel, operation: Operation) : Option[Seq[Name]] = { + * + * Either (1) the operation is defined in the current model and so you don't need to append class name, but can + * simply reply on past datatypes; or (2) concatenate and find recent one + * + * Compute the name for the visitor implementation of the given model and operation, if an implementation + * is required. + */ + def visitorClassName(model: GenericModel, operation: Operation): Option[Seq[Name]] = { val operationName = names.mangle(names.conceptNameOf(operation)) Some(Seq(names.mangle(names.instanceNameOf(model)), operationName)) } @@ -270,12 +277,12 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** - * Instantiates an instance of the domain object. - * - * Same implementation for OO as for visitor. - * - * new Add(new Lit(new Double(1.0)), new Lit(new Double(2.0))) - */ + * Instantiates an instance of the domain object. + * + * Same implementation for OO as for visitor. + * + * new Add(new Lit(new Double(1.0)), new Lit(new Double(2.0))) + */ def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ @@ -288,53 +295,53 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** - * Instantiate an implementation of the visitor. - * - * Required capability of having makeXXX() within the extensible visitors. - * - * {{{ - * Eval makeEval() { - * return new Eval(); - * } - * }}} - * - * If/When the operation has parameters, then they would have to be defined and passed through from makeXXX() into the new XXXX() - */ + * Instantiate an implementation of the visitor. + * + * Required capability of having makeXXX() within the extensible visitors. + * + * {{{ + * Eval makeEval() { + * return new Eval(); + * } + * }}} + * + * If/When the operation has parameters, then they would have to be defined and passed through from makeXXX() into the new XXXX() + */ def instantiateVisitor(message: SendRequest[Expression]): Generator[MethodBodyContext, Expression] = { import ooParadigm.methodBodyCapabilities._ import paradigm.methodBodyCapabilities._ for { self <- selfReference() method <- getMember(self, factory.name(message.request.op)) - instance <- apply(method, message.request.arguments.toSeq.map(_._2)) // no arguments + instance <- apply(method, message.request.arguments.toSeq.map(_._2)) // no arguments } yield instance } /** - * Dispatch in visitor we need to find context on which to accept a visitor. - * - * That is, e.getLeft().accept(new Eval()) + e.getRight().accept(new Eval()); - * - * In particular, when dispatching an operation (with parameters) on an expression, - * we want to return something like this: - * - * $expr.accept(make${op}($args)) - * - * {{{ - * public Double mult(Mult exp) { - * return exp.getLeft().accept(new Eval()) * exp.getRight().accept(new Eval()); - * } - * - * public Double visit(Mult e) { - * return e.getLeft().accept(makeEval()) * e.getRight().accept(makeEval()); - * } - * }}} - * If the operation (i.e., Eval) has parameters, then the makeXXX() should have those and the outer accept(v) remains - * untouched. - * - * @param message the SendRequest to be dispatched. - * @return - */ + * Dispatch in visitor we need to find context on which to accept a visitor. + * + * That is, e.getLeft().accept(new Eval()) + e.getRight().accept(new Eval()); + * + * In particular, when dispatching an operation (with parameters) on an expression, + * we want to return something like this: + * + * $expr.accept(make${op}($args)) + * + * {{{ + * public Double mult(Mult exp) { + * return exp.getLeft().accept(new Eval()) * exp.getRight().accept(new Eval()); + * } + * + * public Double visit(Mult e) { + * return e.getLeft().accept(makeEval()) * e.getRight().accept(makeEval()); + * } + * }}} + * If the operation (i.e., Eval) has parameters, then the makeXXX() should have those and the outer accept(v) remains + * untouched. + * + * @param message the SendRequest to be dispatched. + * @return + */ def dispatch(message: SendRequest[Expression]): Generator[MethodBodyContext, Expression] = { import ooParadigm.methodBodyCapabilities._ import paradigm.methodBodyCapabilities._ @@ -342,7 +349,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { for { // In the "message.to" expression, invoke the 'accept' method with a visitor argument - genericMethod <- getMember(message.to, visitor.accept) // things which are code-generated use the '<-' handles unpacking results + genericMethod <- getMember(message.to, visitor.accept) // things which are code-generated use the '<-' handles unpacking results rt <- toTargetLanguageType(message.request.op.returnType) _ <- resolveAndAddImport(rt) method <- instantiateTypeParameter(genericMethod, Seq(rt)) @@ -352,13 +359,13 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { visitor <- instantiateVisitor(message) // apply to method with the visitor, resulting in the expression - result <- apply(method, Seq(visitor)) // has to be Seq[] just for syntax of calling the method + result <- apply(method, Seq(visitor)) // has to be Seq[] just for syntax of calling the method } yield result } /** Find the last evolution that requires its own TypeCase definition. */ def latestModelDefiningVisitor(domain: GenericModel): GenericModel = { - if (domain.isDomainBase || domain.typeCases.nonEmpty || domain.former.length > 1) { // handle merge case as well + if (domain.isDomainBase || domain.typeCases.nonEmpty || domain.former.length > 1) { // handle merge case as well domain } else { // find where tpe was defined and also where last operation was defined and choose later of the two @@ -369,7 +376,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** Handles situation where operation is redefined in multiple branches because of new data types in each. */ - def latestModelDefiningOperation(domain:GenericModel, op:Operation): Seq[GenericModel] = { + def latestModelDefiningOperation(domain: GenericModel, op: Operation): Seq[GenericModel] = { if ((domain == latestModelDefiningVisitor(domain) && domain.flatten.ops.contains(op)) || domain.ops.contains(op)) { Seq(domain) } else { @@ -380,11 +387,11 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** - * Compute the name for the visitor interface of the given model, if a new interface is required. - * - * Base remains as {visitorClass} - * sub-classes are {visitorClass}DataTypes... - */ + * Compute the name for the visitor interface of the given model, if a new interface is required. + * + * Base remains as {visitorClass} + * sub-classes are {visitorClass}DataTypes... + */ def visitorInterfaceName(model: GenericModel): Seq[Name] = { if (model.isDomainBase) { Seq(visitor.visitorClass) @@ -394,20 +401,20 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** Create an accept implementation from the accept method signature. - * {{{ - * public R accept(Visitor v) { - * if (v instanceof VisitorDivdMultNeg) { - * return ((VisitorDivdMultNeg) v).visit(this); - * } - * throw new RuntimeException("Older visitor used with newer datatype variant."); - * } - * }}} - * - * {{{ - * return ((VisitorDivdMultNeg) v).visit(this); - * }}} - * //TODO: Could change this to perform instanceof check + throw exceptions - */ + * {{{ + * public R accept(Visitor v) { + * if (v instanceof VisitorDivdMultNeg) { + * return ((VisitorDivdMultNeg) v).visit(this); + * } + * throw new RuntimeException("Older visitor used with newer datatype variant."); + * } + * }}} + * + * {{{ + * return ((VisitorDivdMultNeg) v).visit(this); + * }}} + * //TODO: Could change this to perform instanceof check + throw exceptions + */ def makeAcceptImplementation(model: GenericModel): Generator[ClassContext, Unit] = { val makeBody: Generator[MethodBodyContext, Option[Expression]] = { import paradigm.methodBodyCapabilities._ @@ -415,12 +422,12 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { import polymorphics.methodBodyCapabilities._ for { - _ <- visitor.makeAcceptSignatureWithType() // start from the accept signature and add a method body. - args <- getArguments() // get name, type, expression + _ <- visitor.makeAcceptSignatureWithType() // start from the accept signature and add a method body. + args <- getArguments() // get name, type, expression v = args.head._3 - vType = visitorInterfaceName(model) // convert Name to a class + vType = visitorInterfaceName(model) // convert Name to a class - visitorClassType <- findClass(vType : _ *) + visitorClassType <- findClass(vType *) tpeParam <- getTypeArguments() instVisitClassType <- applyType(visitorClassType, tpeParam) castV <- castObject(instVisitClassType, v) @@ -428,7 +435,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { visitFunction <- getMember(castV, visitor.visit) self <- selfReference() - result <- apply(visitFunction, Seq(self)) // make the method invocation + result <- apply(visitFunction, Seq(self)) // make the method invocation } yield Some(result) } @@ -437,53 +444,53 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** - * Just return the expression required for a factory, which must be the name of the class since - * we are the visitor - * - * {{{ - * return new EvalSub(); - * }}} - * - * @return - * - * For Extensible visitor, choose the EARLIEST location of operation and use covariant overiding - */ - def makeFactoryOperationImpl(model:GenericModel, op: Operation, shouldOverride:Boolean, typeName:Seq[Name]): Generator[MethodBodyContext, Option[Expression]] = { + * Just return the expression required for a factory, which must be the name of the class since + * we are the visitor + * + * {{{ + * return new EvalSub(); + * }}} + * + * @return + * + * For Extensible visitor, choose the EARLIEST location of operation and use covariant overiding + */ + def makeFactoryOperationImpl(model: GenericModel, op: Operation, shouldOverride: Boolean, typeName: Seq[Name]): Generator[MethodBodyContext, Option[Expression]] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ // The earliest this operation occurs is the first candidate. BUT must then find whether there is some type such that (op, tpe) has // an overridden implementation. INCLUDING merging val earliest = model.findOperation(op).get - val selected = model.flatten.typeCases.foldLeft(earliest)((earliest,tpe) => + val selected = model.flatten.typeCases.foldLeft(earliest)((earliest, tpe) => model.haveImplementation(PotentialRequest(model.baseDataType, tpe, op)).foldLeft(earliest)((earliest, m) => m.later(earliest))) // doesn't handle MERGE well.... val possible = model.inChronologicalOrder.filter(m => m.former.length > 1 && selected.earlier(m) == selected) val chosen = if (possible.nonEmpty) { // could be multiple? So take the last one - possible.last // head + possible.last // head } else { selected } - for { + for { // Type signature uses the earliest one to define, but instantiates the latest with covariant overriding. - earliestOpClass <- findClass(visitorClassName(earliest, op).get : _ *) + earliestOpClass <- findClass(visitorClassName(earliest, op).get *) _ <- resolveAndAddImport(earliestOpClass) _ <- setReturnType(earliestOpClass) - latestOpClass <- findClass(visitorClassName(chosen, op).get : _ *) // findClass(typeName : _ *) + latestOpClass <- findClass(visitorClassName(chosen, op).get *) // findClass(typeName : _ *) _ <- resolveAndAddImport(latestOpClass) // need parameters for operations with parameters - params <- forEach (op.parameters) { param => + params <- forEach(op.parameters) { param => for { paramTy <- toTargetLanguageType(param.tpe) _ <- resolveAndAddImport(paramTy) pName <- freshName(names.mangle(param.name)) } yield (pName, paramTy) } - _ <- setParameters(params) // params: Seq[(Name, Type)] + _ <- setParameters(params) // params: Seq[(Name, Type)] // subsequent ones need to override. _ <- if (shouldOverride) { @@ -493,11 +500,11 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } args <- getArguments() - res <- instantiateObject(latestOpClass,args.map(_._3)) + res <- instantiateObject(latestOpClass, args.map(_._3)) } yield Some(res) } - def makeEachVisitorInterface(domain:GenericModel): Generator[ClassContext, Unit] = { + def makeEachVisitorInterface(domain: GenericModel): Generator[ClassContext, Unit] = { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ @@ -506,18 +513,18 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { visitTyParam <- freshName(names.mangle(visitor.visitTypeParameter)) _ <- addTypeParameter(visitTyParam, Command.skip) // R by itself, since not extending any other type parameter (hence Skip) visitResultType <- getTypeArguments().map(_.head) - _ <- forEach (domain.typeCases) { tpe => addAbstractMethod(visitor.visit, makeEachVisitSignature(domain, tpe, visitResultType)) } + _ <- forEach(domain.typeCases) { tpe => addAbstractMethod(visitor.visit, makeEachVisitSignature(domain, tpe, visitResultType)) } } yield () } /** Take existing visitor generated by Shared and add (where needed) a "extends VisitorSub" - * - * @param domain create visitor interface for the given model in the extension graph. - * @return - */ - def makeExtensibleVisitorInterface(domain:GenericModel): Generator[ClassContext, Unit] = { + * + * @param domain create visitor interface for the given model in the extension graph. + * @return + */ + def makeExtensibleVisitorInterface(domain: GenericModel): Generator[ClassContext, Unit] = { // ignore degenerate case where the first model only has an operation without any types - def addParentInterfaces(): Generator[ClassContext, Unit] = { + def addParentInterfaces(): Generator[ClassContext, Unit] = { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ @@ -528,7 +535,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { _ <- forEach(parentModels) { parent => { for { // find former Op interface - visitorInterfaceType <- findClass(visitorInterfaceName(parent): _ *) + visitorInterfaceType <- findClass(visitorInterfaceName(parent) *) _ <- resolveAndAddImport(visitorInterfaceType) visitTyParam <- getTypeArguments() // can do this because we need this interfaces paramType @@ -542,12 +549,12 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } for { - _ <- makeEachVisitorInterface(domain) // Inherit past type cases from parent visitors + _ <- makeEachVisitorInterface(domain) // Inherit past type cases from parent visitors _ <- addParentInterfaces() } yield () } - def makeEachVisitSignature(domain:GenericModel, tpe:DataTypeCase, visitResultType: Type): Generator[MethodBodyContext, Unit] = { + def makeEachVisitSignature(domain: GenericModel, tpe: DataTypeCase, visitResultType: Type): Generator[MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities.{toTargetLanguageType => _, _} import polymorphics.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ @@ -555,15 +562,17 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { val whereDefined = domain.findTypeCase(tpe).get for { _ <- setReturnType(visitResultType) - visitedClassType <- findClass(dataTypeClassName(whereDefined,tpe) : _ *) + visitedClassType <- findClass(dataTypeClassName(whereDefined, tpe) *) _ <- resolveAndAddImport(visitedClassType) visitParamName <- freshName(names.mangle(visitor.expParameter)) - _ <- setParameters(Seq((visitParamName, visitedClassType))) // a pair (name,type) of only one sequence + _ <- setParameters(Seq((visitParamName, visitedClassType))) // a pair (name,type) of only one sequence } yield () } - override def makeTypeCaseImplementation(tpe: DataType, tpeCase: DataTypeCase, op: Operation, domain:GenericModel, - domainSpecific: EvolutionImplementationProvider[this.type]): Generator[MethodBodyContext, Option[Expression]] = { + override def makeTypeCaseImplementation( + tpe: DataType, tpeCase: DataTypeCase, op: Operation, domain: GenericModel, + domainSpecific: EvolutionImplementationProvider[this.type] + ): Generator[MethodBodyContext, Option[Expression]] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ val properModel = latestModelDefiningOperatorClass(domain, tpeCase, op, domainSpecific).get @@ -573,19 +582,19 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { _ <- resolveAndAddImport(returnType) _ <- makeEachVisitSignature(domain, tpeCase, returnType) _ <- if (!domain.ops.contains(op)) { - setOverride() // Hmmm: Might be able to infer this from the model and operation + setOverride() // Hmmm: Might be able to infer this from the model and operation } else { Command.skip[MethodBodyContext] } visitedRef <- getArguments().map(_.head._3) - attAccessors: Seq[Expression] <- forEach (tpeCase.attributes) { att => + attAccessors: Seq[Expression] <- forEach(tpeCase.attributes) { att => for { getter <- getMember(visitedRef, getterName(att)) getterCall <- apply(getter, Seq.empty) } yield getterCall } - args <- forEach (op.parameters) { param => + args <- forEach(op.parameters) { param => for { thisRef <- selfReference() paramField <- getMember(thisRef, names.mangle(param.name)) @@ -594,15 +603,15 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { // body of this implementation is the result of the individual domain-specific logic. result <- domainSpecific.logic(this)( - ReceivedRequest( - tpe, - tpeCase, - visitedRef, - tpeCase.attributes.zip(attAccessors).toMap, - Request(op, args.toMap), - Some(properModel) // scala implementation for j8 needed this - ) + ReceivedRequest( + tpe, + tpeCase, + visitedRef, + tpeCase.attributes.zip(attAccessors).toMap, + Request(op, args.toMap), + Some(properModel) // scala implementation for j8 needed this ) + ) } yield result } @@ -613,9 +622,9 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { ): Set[Operation] = { val allTpeCases = domain.flatten.typeCases.distinct val allDependencies = allTpeCases.map(tpeCase => domainSpecific.evolutionSpecificDependencies(PotentialRequest(domain.baseDataType, tpeCase, op))) - val combinedDependencies = allDependencies.foldLeft(Map.empty[GenericModel, Set[Operation]]){ case (combined, singular) => + val combinedDependencies = allDependencies.foldLeft(Map.empty[GenericModel, Set[Operation]]) { case (combined, singular) => val allDomainsWithDependencies = singular.keySet ++ combined.keySet - allDomainsWithDependencies.foldLeft(Map.empty[GenericModel, Set[Operation]]){ case (newCombinedMap, currentDomain) => + allDomainsWithDependencies.foldLeft(Map.empty[GenericModel, Set[Operation]]) { case (newCombinedMap, currentDomain) => newCombinedMap + (currentDomain -> (singular.getOrElse(currentDomain, Set.empty) ++ combined.getOrElse(currentDomain, Set.empty))) } } @@ -626,33 +635,35 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { val lastPriorDomainsDeclaringDependencies = priorDomainsDeclaringDependencies.filter(d1 => !priorDomainsDeclaringDependencies.exists(d2 => d1.before(d2)) ) - lastPriorDomainsDeclaringDependencies.foldLeft[Set[Operation]](Set.empty){ case (s, d) => s ++ combinedDependencies(d) } + lastPriorDomainsDeclaringDependencies.foldLeft[Set[Operation]](Set.empty) { case (s, d) => s ++ combinedDependencies(d) } } } /** Each operation is placed in its own class, with a 'visit' method for newly defined types. - * - * {{{ - * public class EvalSub extends Eval implements VisitorSub { - * - * public Double visit(Sub e) { - * return e.getLeft().accept(makeEval()) - e.getRight().accept(makeEval()); - * } - * - * EvalSub makeEval() { - * return new EvalSub(); - * } - * } - * }}} - * - * @param domain Model for which new types are to be incorporated - * @param operation operation that needs an implementation - * @param domainSpecific contains the logic - * @return Returns class context without actually adding to ProjectContext; this is job of caller of this function - */ - def makeExtensibleOperationImplementation(domain:GenericModel, - operation: Operation, - domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = { + * + * {{{ + * public class EvalSub extends Eval implements VisitorSub { + * + * public Double visit(Sub e) { + * return e.getLeft().accept(makeEval()) - e.getRight().accept(makeEval()); + * } + * + * EvalSub makeEval() { + * return new EvalSub(); + * } + * } + * }}} + * + * @param domain Model for which new types are to be incorporated + * @param operation operation that needs an implementation + * @param domainSpecific contains the logic + * @return Returns class context without actually adding to ProjectContext; this is job of caller of this function + */ + def makeExtensibleOperationImplementation( + domain: GenericModel, + operation: Operation, + domainSpecific: EvolutionImplementationProvider[this.type] + ): Generator[ClassContext, Unit] = { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ @@ -673,7 +684,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { tpe, operation )) - val containsOverride = knownDependencies.exists{ case (overridingDomain, _) => + val containsOverride = knownDependencies.exists { case (overridingDomain, _) => primaryParent.before(overridingDomain) && overridingDomain.beforeOrEqual(domain) } !primaryParentTypeCases.contains(tpe) || containsOverride @@ -684,38 +695,38 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { // if you get the last model with data types, you should stop if op is defined AFTER // that one (for example with PrettyP which is defined in M2 but Sub is defined in M1) def addParentClass(): Generator[ClassContext, Option[Type]] = if (domain.isDomainBase) { - Command.lift[ClassContext, Option[Type]](Option.empty) - } else { - val latestVisitor = latestModelDefiningVisitor(domain) + Command.lift[ClassContext, Option[Type]](Option.empty) + } else { + val latestVisitor = latestModelDefiningVisitor(domain) - for { - visitTyParam <- toTargetLanguageType(operation.returnType) // can do this because we need this interfaces paramType - _ <- resolveAndAddImport(visitTyParam) - visitorClassType <- findClass(visitorInterfaceName(latestVisitor) : _ *) - _ <- resolveAndAddImport(visitorClassType) + for { + visitTyParam <- toTargetLanguageType(operation.returnType) // can do this because we need this interfaces paramType + _ <- resolveAndAddImport(visitTyParam) + visitorClassType <- findClass(visitorInterfaceName(latestVisitor) *) + _ <- resolveAndAddImport(visitorClassType) - modifiedType <- applyType(visitorClassType, Seq(visitTyParam)) - _ <- addImplemented(modifiedType) + modifiedType <- applyType(visitorClassType, Seq(visitTyParam)) + _ <- addImplemented(modifiedType) - possibleParent <- if (previous.nonEmpty) { - val primaryParent = previous.maxBy(m => m.flatten.typeCases.length) - for { - parentType <- findClass(visitorClassName(primaryParent, operation).get : _ *) - _ <- resolveAndAddImport(parentType) - _ <- addParent(parentType) - } yield Some(parentType) - } else { - Command.lift[ClassContext,Option[Type]](Option.empty) - } + possibleParent <- if (previous.nonEmpty) { + val primaryParent = previous.maxBy(m => m.flatten.typeCases.length) + for { + parentType <- findClass(visitorClassName(primaryParent, operation).get *) + _ <- resolveAndAddImport(parentType) + _ <- addParent(parentType) + } yield Some(parentType) + } else { + Command.lift[ClassContext, Option[Type]](Option.empty) + } - } yield possibleParent - } + } yield possibleParent + } // Later evolution stages can remove a past dependent operation or possibly add. First tuple is // m0 and the last one is the current domain. val wholeStructure = domain.inChronologicalOrder.map(m => dependentOperationsOf(m, operation, domainSpecific)) - val reduced:Set[Operation] = wholeStructure.foldLeft(Set.empty[Operation])((aggregate, ops) => + val reduced: Set[Operation] = wholeStructure.foldLeft(Set.empty[Operation])((aggregate, ops) => if (ops.isEmpty) { Set.empty[Operation] } else { @@ -724,7 +735,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { ) //val opsSeq:Seq[Operation] = (Seq(operation) ++ domain.inChronologicalOrder.flatMap(m => dependentOperationsOf(m, operation, domainSpecific))).distinct - val opsSeq:Seq[Operation] = (Seq(operation) ++ reduced).distinct + val opsSeq: Seq[Operation] = (Seq(operation) ++ reduced).distinct for { possibleParent <- addParentClass() @@ -739,7 +750,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { _ <- addConstructor(visitor.makeOperationConstructor(operation, possibleParent)) // for all that are not in primary parent - _ <- forEach (typeCasesToDeclare) { tpe => + _ <- forEach(typeCasesToDeclare) { tpe => for { _ <- addMethod(visitor.visit, makeTypeCaseImplementation(domain.baseDataType, tpe, operation, domain, domainSpecific)) @@ -752,27 +763,27 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { // might have to go backward in time to find the model that declared that operation or had // an intervening visitor declaration. _ <- forEach(opsSeq) { dop => - val modelsToUse = latestModelDefiningOperation(domain, dop) - val modelToUse = modelsToUse.head + val modelsToUse = latestModelDefiningOperation(domain, dop) + val modelToUse = modelsToUse.head /** - * There is special case in k1 for MultBy, which needs a makeEval factory method but it isn't overridden - * because it is a dependent operation and appears for the first time. - * - * makeIsNeg in the Eql.java file in j3 DOES NOT override because it is first presence. Fix this by - * identifying that while the operation came from the PAST the dependent operations are, in fact, defined - * in modelToUse so they cannot be overridden. DONE - * - * Harder one is k1.MultBy which has a dependent operation Eval, but ONLY for the first time in K1 and - * no one before. IN Java if this is public without @Override annotation it works OK. However in Scala - * there truly needs to be the "override" keyword. - * - * Final one is a result of single inheritance. Once k2j6 decides to extend from j3 branch, methods that - * HAD been defined in the k2 branch no longer deserve to be overridden. SO we somehow have to - * ensure that the dependent operation comes from the non-inherited branch, it DOES NOT get overriden, - * otherwise it must. - * - */ + * There is special case in k1 for MultBy, which needs a makeEval factory method but it isn't overridden + * because it is a dependent operation and appears for the first time. + * + * makeIsNeg in the Eql.java file in j3 DOES NOT override because it is first presence. Fix this by + * identifying that while the operation came from the PAST the dependent operations are, in fact, defined + * in modelToUse so they cannot be overridden. DONE + * + * Harder one is k1.MultBy which has a dependent operation Eval, but ONLY for the first time in K1 and + * no one before. IN Java if this is public without @Override annotation it works OK. However in Scala + * there truly needs to be the "override" keyword. + * + * Final one is a result of single inheritance. Once k2j6 decides to extend from j3 branch, methods that + * HAD been defined in the k2 branch no longer deserve to be overridden. SO we somehow have to + * ensure that the dependent operation comes from the non-inherited branch, it DOES NOT get overriden, + * otherwise it must. + * + */ // HOWEVER, if you are a dependent operation in a merge val do_override = if (operation != dop) { @@ -780,7 +791,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { false } else { // this is a dependent operation and MUST CHECK to see if any place in past this same dependent operation had been generated. - val primaryParent:Option[GenericModel] = if (previous.nonEmpty) { + val primaryParent: Option[GenericModel] = if (previous.nonEmpty) { Some(previous.maxBy(m => m.flatten.typeCases.length)) } else { None @@ -810,28 +821,28 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { // ever happens, logic like above could be used, though .filter (p => p.beforeOrEqual(primaryParent.get)).head n = n.former.head } - exists_in_past // if exists in past, then must override + exists_in_past // if exists in past, then must override } } else { // for O1 need to double check modelToUse != domain since means parent exists - (!modelToUse.ops.contains(operation)) || (modelToUse != domain) // if same COULD be defining, but only if previously defined + (!modelToUse.ops.contains(operation)) || (modelToUse != domain) // if same COULD be defining, but only if previously defined } /** - - These three are fixed with checking modelToUse.ops.contains(operation) - j3\IsDivd = makeEql - j3\IsNeg => makeEql - k1\IsPower => makeEql (because IsPower is new operation) - - * FINAL SET! THESE ALL are overriding BUT SHOULD NOT be. Fixed above - - x j6\PowBy => makeEval (because eval is dependency) - x k1\MultBy => makeEval (because EIP has implementation) - x k2\Simplify => makeEval - x k2j6\Eql => makeIsPower (NOT overriding since primary inheritance through J branch - x k2j6\MultBy => makeEval (NOT overriding since primary inheritance through J branch - */ + * + * These three are fixed with checking modelToUse.ops.contains(operation) + * j3\IsDivd = makeEql + * j3\IsNeg => makeEql + * k1\IsPower => makeEql (because IsPower is new operation) + * + * FINAL SET! THESE ALL are overriding BUT SHOULD NOT be. Fixed above + * + * x j6\PowBy => makeEval (because eval is dependency) + * x k1\MultBy => makeEval (because EIP has implementation) + * x k2\Simplify => makeEval + * x k2j6\Eql => makeIsPower (NOT overriding since primary inheritance through J branch + * x k2j6\MultBy => makeEval (NOT overriding since primary inheritance through J branch + */ // dependent operations in their first use are not overridden. factory.create(modelToUse, dop, do_override, visitorClassName(modelToUse, dop).get) @@ -840,17 +851,18 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** - * Define the base class for Exp - * {{{ - * package visitor; - * public abstract class Exp { - * public abstract R accept(Visitor v); - * } - * }}} - * @param model generate base class for the given domain - * @return - */ - def makeOperationsBase(model:GenericModel): Generator[ProjectContext, Unit] = { + * Define the base class for Exp + * {{{ + * package visitor; + * public abstract class Exp { + * public abstract R accept(Visitor v); + * } + * }}} + * + * @param model generate base class for the given domain + * @return + */ + def makeOperationsBase(model: GenericModel): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ val makeClass: Generator[ClassContext, Unit] = { @@ -865,32 +877,33 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { addClassToProject(makeClass, names.mangle(names.conceptNameOf(model.baseDataType))) } - def locateTypeCaseClass[Context](domain: GenericModel, dataTypeCase:DataTypeCase)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], + def locateTypeCaseClass[Context](domain: GenericModel, dataTypeCase: DataTypeCase)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], ): Generator[Context, paradigm.syntax.Type] = { for { - dataTypeCaseClass <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](dataTypeClassName(domain,dataTypeCase)).interpret(canFindClass) + dataTypeCaseClass <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](dataTypeClassName(domain, dataTypeCase)).interpret(canFindClass) _ <- resolveAndAddImport(dataTypeCaseClass) } yield dataTypeCaseClass } /** - * Default registration for findClass, which works with each registerTypeMapping for the different approaches. - * - * Sometimes the mapping is fixed for an EP approach, but sometimes it matters when a particular class is requested - * in the evolution of the system over time. - * - * @param domain find base-type class - * @tparam Ctxt the Context (to allow for multiple usages) - * @return - */ - def domainTypeLookup[Ctxt](domain:GenericModel)(implicit canFindClass: Understands[Ctxt, FindClass[Name, Type]]): Generator[Ctxt, Type] = { + * Default registration for findClass, which works with each registerTypeMapping for the different approaches. + * + * Sometimes the mapping is fixed for an EP approach, but sometimes it matters when a particular class is requested + * in the evolution of the system over time. + * + * @param domain find base-type class + * @tparam Ctxt the Context (to allow for multiple usages) + * @return + */ + def domainTypeLookup[Ctxt](domain: GenericModel)(implicit canFindClass: Understands[Ctxt, FindClass[Name, Type]]): Generator[Ctxt, Type] = { FindClass(Seq(names.mangle(names.conceptNameOf(domain.baseDataType)))).interpret(canFindClass) } - def registerNewlyDeclaredDataTypeClasses(model:GenericModel): Generator[ProjectContext, Unit] = { + def registerNewlyDeclaredDataTypeClasses(model: GenericModel): Generator[ProjectContext, Unit] = { import paradigm.projectCapabilities.addTypeLookupForMethods import ooParadigm.projectCapabilities.addTypeLookupForClasses import ooParadigm.projectCapabilities.addTypeLookupForConstructors @@ -911,11 +924,11 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { import ooParadigm.projectCapabilities.addTypeLookupForClasses import ooParadigm.projectCapabilities.addTypeLookupForConstructors - import ooParadigm.methodBodyCapabilities.canFindClassInMethod // These three all are needed + import ooParadigm.methodBodyCapabilities.canFindClassInMethod // These three all are needed import ooParadigm.classCapabilities.canFindClassInClass import ooParadigm.constructorCapabilities.canFindClassInConstructor - val dtpeRep = TypeRep.DataType(domain.baseDataType) + val dtpeRep = DomainTpeRep.DataType(domain.baseDataType) for { _ <- addTypeLookupForMethods(dtpeRep, domainTypeLookup(domain)) @@ -924,39 +937,40 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } yield () } - def addOperationsAsClasses(operations:Seq[Operation], model:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]) : Generator[ProjectContext,Unit] = { + def addOperationsAsClasses(operations: Seq[Operation], model: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ import paradigm.projectCapabilities._ for { _ <- forEach(operations) { op => { - addClassToProject(makeExtensibleOperationImplementation(model, op, domainSpecific), visitorClassName(model, op).get : _ *) - }} + addClassToProject(makeExtensibleOperationImplementation(model, op, domainSpecific), visitorClassName(model, op).get *) + } + } } yield () } - def makeDerivedClassesInChronologicalOrder(gdomain:GenericModel) : Generator[ProjectContext, Unit] = { + def makeDerivedClassesInChronologicalOrder(gdomain: GenericModel): Generator[ProjectContext, Unit] = { for { _ <- forEach(gdomain.inChronologicalOrder) { dm => for { _ <- registerNewlyDeclaredDataTypeClasses(dm) - _ <- forEach (dm.typeCases) {tpeCase => + _ <- forEach(dm.typeCases) { tpeCase => for { - _ <- visitor.makeDerived (gdomain.baseDataType, tpeCase, dm) + _ <- visitor.makeDerived(gdomain.baseDataType, tpeCase, dm) } yield () } } yield () } } yield () } - - def makeOperationsClassesInChronologicalOrder(gdomain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]) : Generator[ProjectContext, Unit] = { + + def makeOperationsClassesInChronologicalOrder(gdomain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ for { // WHEN new data types are added and there are existing operations in the past // need to run generators in sequence and when that happens you need to group with a for {...} yield() - _ <- forEach (gdomain.inChronologicalOrder) { m => { + _ <- forEach(gdomain.inChronologicalOrder) { m => { for { _ <- registerNewlyDeclaredDataTypeClasses(m) @@ -964,21 +978,21 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { // add their corresponding classes. _ <- if (m == latestModelDefiningVisitor(m)) { for { - _ <- addClassToProject(makeExtensibleVisitorInterface(m), visitorInterfaceName(m) : _ *) + _ <- addClassToProject(makeExtensibleVisitorInterface(m), visitorInterfaceName(m) *) _ <- addOperationsAsClasses(m.flatten.ops, m, domainSpecific) } yield () } else { // For overridden operations that were defined IN THE PAST have to add those to m.ops val flat = m.flatten - val over = flat.typeCases.flatMap{ tpe => - flat.ops.filter{ op => + val over = flat.typeCases.flatMap { tpe => + flat.ops.filter { op => domainSpecific.evolutionSpecificDependencies( PotentialRequest(m.baseDataType, tpe, op) ).contains(m) } }.toSet - addOperationsAsClasses(m.ops ++ over, m, domainSpecific) // these override from past + addOperationsAsClasses(m.ops ++ over, m, domainSpecific) // these override from past } } yield () } @@ -987,26 +1001,26 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } /** - * The Extensible Visitor approach is defined as follows. This handles the code generation for the implementation - * - * 1. Make the base class (for the domain) - * 2. For each of the data types (in flattened set) create a derived class - * 3. Create the Visitor interface - * - * @param gdomain final node in extension graph - * @param domainSpecific final eip corresponding to this final node - * @return - */ + * The Extensible Visitor approach is defined as follows. This handles the code generation for the implementation + * + * 1. Make the base class (for the domain) + * 2. For each of the data types (in flattened set) create a derived class + * 3. Create the Visitor interface + * + * @param gdomain final node in extension graph + * @param domainSpecific final eip corresponding to this final node + * @return + */ override def implement(gdomain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ import paradigm.projectCapabilities._ for { - _ <- debug ("Processing Extensible Visitor") + _ <- debug("Processing Extensible Visitor") _ <- domainSpecific.initialize(this) _ <- visitor.makeBase(gdomain.baseDataType) _ <- registerTypeMapping(gdomain) - _ <- addClassToProject(visitor.makeVisitorInterface(Seq.empty), visitor.visitorClass) // top-level Visitor + _ <- addClassToProject(visitor.makeVisitorInterface(Seq.empty), visitor.visitorClass) // top-level Visitor _ <- makeOperationsBase(gdomain) _ <- makeOperationsClassesInChronologicalOrder(gdomain, domainSpecific) @@ -1035,14 +1049,15 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { _ <- addTestCase(testCode, testName) // each operation gets a factory that is added using the 'addMethodInTest' capabilities. - _ <- forEach (model.flatten.ops.distinct) { op => { + _ <- forEach(model.flatten.ops.distinct) { op => { for { _ <- addMethod(factory.name(op), makeFactoryOperationImpl(model, op, shouldOverride = false, visitorClassName(latestModelDefiningOperation(model, op).head, op).get)) } yield () - }} + } + } - } yield() + } yield () val testSuite = for { _ <- addTestSuite( @@ -1062,20 +1077,26 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass { } object ExtensibleVisitor { - type WithParadigm[P <: AnyParadigm] = ExtensibleVisitor { val paradigm: P } + type WithParadigm[P <: AnyParadigm] = ExtensibleVisitor {val paradigm: P} type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] - (base: P) - (nameProvider: NameProvider[base.syntax.Name], - oo: ObjectOriented.WithBase[base.type], - params: ParametricPolymorphism.WithBase[base.type]) - (generics: Generics.WithBase[base.type,oo.type,params.type]): ExtensibleVisitor.WithParadigm[base.type] = - new ExtensibleVisitor { - val paradigm: base.type = base - val names: NameProvider[paradigm.syntax.Name] = nameProvider - val ooParadigm: oo.type = oo - val polymorphics: params.type = params - val genericsParadigm: generics.type = generics - } -} + (base: P) + ( + nameProvider: NameProvider[base.syntax.Name], + oo: ObjectOriented.WithBase[base.type], + params: ParametricPolymorphism.WithBase[base.type] + ) + (generics: Generics.WithBase[base.type, oo.type, params.type]): ExtensibleVisitor.WithParadigm[base.type] = { + case class EV( + override val paradigm: base.type + )( + override val names: NameProvider[paradigm.syntax.Name], + override val ooParadigm: oo.type, + override val polymorphics: params.type + )( + override val genericsParadigm: generics.type = generics + ) extends ExtensibleVisitor + EV(base)(nameProvider, oo, params)(generics) + } +} \ No newline at end of file diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala similarity index 55% rename from core/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala index 35455a7a..a0c6dd83 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala @@ -1,12 +1,17 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ +package org.combinators.ep.approach.oo +/*DI:LI:AD*/ + +import org.combinators.cogen.{Command, TestCase, TypeRep, Understands, NameProvider, AbstractSyntax} +import Command.Generator +import org.combinators.cogen.paradigm._ +import org.combinators.cogen.paradigm.{AddImport, AnyParadigm, Apply, FindClass, Generics, ObjectOriented, ParametricPolymorphism, ResolveImport} import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.generator.Command._ +import org.combinators.ep.domain.extensions._ import org.combinators.ep.generator._ import org.combinators.ep.generator.communication._ -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.{forEach, _} -import org.combinators.ep.generator.paradigm._ +import org.combinators.cogen.paradigm.AnyParadigm.syntax.{forEach, *} sealed trait Interpreter extends SharedOO { val ooParadigm: ObjectOriented.WithBase[paradigm.type] @@ -18,15 +23,15 @@ sealed trait Interpreter extends SharedOO { import syntax._ /** - * Extended Intermediate Interface (i.e., ep.m3.Exp) is only created when - * needed, specifically: (a) a new operation is being defined, and this interface will host the default - * implementation; or (b) a branch is being merged from branches in which new Exp had been defined - * useful when determining merging - * - * Also found in CoCo - * - * @param domain under investigation - */ + * Extended Intermediate Interface (i.e., ep.m3.Exp) is only created when + * needed, specifically: (a) a new operation is being defined, and this interface will host the default + * implementation; or (b) a branch is being merged from branches in which new Exp had been defined + * useful when determining merging + * + * Also found in CoCo + * + * @param domain under investigation + */ def ancestorsDefiningNewTypeInterfaces(domain: GenericModel): Set[GenericModel] = { val ancestorsWithNewTypeInterfaces = domain.former.map(ancestor => latestModelDefiningNewTypeInterface(ancestor)) @@ -39,22 +44,22 @@ sealed trait Interpreter extends SharedOO { // current domain might have implementation that overrides an existing implementation, and that has // to be captured. Go through all past operations and past data types, and see if the domainSpecific dependencies - var returnVal:Option[GenericModel] = None + var returnVal: Option[GenericModel] = None domain.pastOperations.foreach(op => domain.pastDataTypes.foreach(tpe => - // cannot just invoke 'haveImplementation' since that covers cases where a new data type has been defined, - // and so a past operation needs to be implemented. ONLY deal with optimizations - if (domain.optimizations.contains((tpe, op))) { - returnVal = Some(domain) - } - ) + // cannot just invoke 'haveImplementation' since that covers cases where a new data type has been defined, + // and so a past operation needs to be implemented. ONLY deal with optimizations + if (domain.optimizations.contains((tpe, op))) { + returnVal = Some(domain) + } ) + ) returnVal } - def updatedImplementationCurrentDomainByType(domain: GenericModel, tpe:DataTypeCase): Option[GenericModel] = { + def updatedImplementationCurrentDomainByType(domain: GenericModel, tpe: DataTypeCase): Option[GenericModel] = { // the domain (or an ancestor) might have implementation that overrides an existing implementation, and // that has to be captured. Go through all past operations for this data type, and see if there are // domainSpecific dependencies @@ -63,20 +68,20 @@ sealed trait Interpreter extends SharedOO { } /** - * When there is a new operation, definitely need a new Exp interface. - * - * Merge case handed here. - * - * Also duplicated in CoCo but with modifications. In 'Interpreter' you do not need to create a Type interface - * for a stage that is purely merging in new data types after operations. - */ + * When there is a new operation, definitely need a new Exp interface. + * + * Merge case handed here. + * + * Also duplicated in CoCo but with modifications. In 'Interpreter' you do not need to create a Type interface + * for a stage that is purely merging in new data types after operations. + */ def latestModelDefiningNewTypeInterface(domain: GenericModel): GenericModel = { if (domain.isDomainBase || domain.ops.nonEmpty) { domain } else { // is there a single type that can represent the "least upper bound" of all prior branches. - val ancestorsWithTypeInterfaces = ancestorsDefiningNewTypeInterfaces(domain) // INTERPRETER - //val ancestorsWithTypeInterfaces = domain.former.map(ancestor => latestModelDefiningNewTypeInterface(ancestor)).distinct // COCO + val ancestorsWithTypeInterfaces = ancestorsDefiningNewTypeInterfaces(domain) // INTERPRETER + //val ancestorsWithTypeInterfaces = domain.former.map(ancestor => latestModelDefiningNewTypeInterface(ancestor)).distinct // COCO if (ancestorsWithTypeInterfaces.size == 1 && !ancestorsWithTypeInterfaces.head.isDomainBase) { // take care to avoid falling below "floor" ancestorsWithTypeInterfaces.head @@ -86,11 +91,12 @@ sealed trait Interpreter extends SharedOO { } } - def mostSpecificBaseInterfaceType[Context](domain: GenericModel)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], - canApplyType: Understands[Context, Apply[paradigm.syntax.Type, paradigm.syntax.Type, paradigm.syntax.Type]], + def mostSpecificBaseInterfaceType[Context](domain: GenericModel)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], + canApplyType: Understands[Context, Apply[paradigm.syntax.Type, paradigm.syntax.Type, paradigm.syntax.Type]], ): Generator[Context, paradigm.syntax.Type] = { // might have to use current because of revised implementation @@ -117,29 +123,29 @@ sealed trait Interpreter extends SharedOO { } /** Place dataType classes in appropriate package. */ - def qualifiedDataTypeCase(domain: GenericModel, tpe:DataTypeCase): Seq[Name] = { + def qualifiedDataTypeCase(domain: GenericModel, tpe: DataTypeCase): Seq[Name] = { Seq(names.mangle(names.instanceNameOf(domain)), names.mangle(names.conceptNameOf(tpe))) } //// ----- Base Data Type As Instance /** - * Base Exp interface with no methods (for now). - * - * {{{ - * public interface Exp { - * public tree.Tree astree(); // only when needed - * } - * }}} - * - * Eventually will have some work here for producer/binary methods - * - * Override traditional OO use where this is a class; here it is an interface - * - * @param tpe -- data type case for which Base is needed - * @param ops -- ignored in this overridden capability - * @return - */ + * Base Exp interface with no methods (for now). + * + * {{{ + * public interface Exp { + * public tree.Tree astree(); // only when needed + * } + * }}} + * + * Eventually will have some work here for producer/binary methods + * + * Override traditional OO use where this is a class; here it is an interface + * + * @param tpe -- data type case for which Base is needed + * @param ops -- ignored in this overridden capability + * @return + */ def makeBase(tpe: DataType, ops: Seq[Operation]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ val makeClass: Generator[ClassContext, Unit] = { @@ -164,9 +170,9 @@ sealed trait Interpreter extends SharedOO { } /** - * Make sure to include past producer methods as well... - */ - def makeInterface(domain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = { + * Make sure to include past producer methods as well... + */ + def makeInterface(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = { // create class which is an interface containing abstract methods import classCapabilities._ import genericsParadigm.classCapabilities._ @@ -182,28 +188,30 @@ sealed trait Interpreter extends SharedOO { // former merge points need to be included, so past.lastModelWithOperation) is changed to below. Make // sure to 'distinct' these models to avoid adding same interface multiple time (can happen with 3-way merge) - _ <- forEach(domain.former.map(past => latestModelDefiningNewTypeInterface(past)).distinct) { m => for { - /** Interpreter has to go back to the former Model which had defined an operation */ - parent <- findClass(qualifiedBaseDataType(m) : _ *) - _ <- resolveAndAddImport(parent) - _ <- addParent(parent) - } yield () - } + _ <- forEach(domain.former.map(past => latestModelDefiningNewTypeInterface(past)).distinct) { m => + for { + /** Interpreter has to go back to the former Model which had defined an operation */ + parent <- findClass(qualifiedBaseDataType(m) *) + _ <- resolveAndAddImport(parent) + _ <- addParent(parent) + } yield () + } // grab current operations AND all producers. Do together to eliminate duplicates. - _ <- forEach ((domain.ops ++ opsToBuild ++ producers).distinct) { op => addAbstractMethod(names.mangle(names.instanceNameOf(op)), makeInterpreterSignature(domain, op)) } + _ <- forEach((domain.ops ++ opsToBuild ++ producers).distinct) { op => addAbstractMethod(names.mangle(names.instanceNameOf(op)), makeInterpreterSignature(domain, op)) } } yield () } /** - * Create intermediate interfaces that form a chain of operation definitions. - * Now this is created EVEN when an evolution doesn't create an operation. - * - * Make sure producer methods are subsequently copied... - */ - def addIntermediateInterfaceToProject(domain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { + * Create intermediate interfaces that form a chain of operation definitions. + * Now this is created EVEN when an evolution doesn't create an operation. + * + * Make sure producer methods are subsequently copied... + */ + def addIntermediateInterfaceToProject(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ - addClassToProject(makeInterface(domain, domainSpecific), baseInterfaceNames(domain) : _*) } + addClassToProject(makeInterface(domain, domainSpecific), baseInterfaceNames(domain) *) + } /// -------------------------------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------------------------------- @@ -223,7 +231,7 @@ sealed trait Interpreter extends SharedOO { for { // goal is to find the class, i.e., "Sub", and have that become "ep.m4.Sub" // Using 'toTargetLanguage' brings in the type from where it had been registered using registerTypes - rt <- toTargetLanguageType(TypeRep.DataType(DataType(tpeCase.name))) + rt <- toTargetLanguageType(DomainTpeRep.DataType(DataType(tpeCase.name))) _ <- resolveAndAddImport(rt) res <- instantiateObject(rt, args) @@ -231,28 +239,29 @@ sealed trait Interpreter extends SharedOO { } /** Create signature using contravariant baseDomain type from past Exps. - * - * {{{ - * public Double OPERATION(PARAM...) - * }}} - * @param op operation for which method needs to be written - * @param domain current domain for the operation. - * @return - */ - def makeInterpreterSignature(domain:GenericModel, op: Operation): Generator[MethodBodyContext, Unit] = { + * + * {{{ + * public Double OPERATION(PARAM...) + * }}} + * + * @param op operation for which method needs to be written + * @param domain current domain for the operation. + * @return + */ + def makeInterpreterSignature(domain: GenericModel, op: Operation): Generator[MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ for { - rt <- toTargetLanguageType(op.returnType) // covariant overriding is still feasible + rt <- toTargetLanguageType(op.returnType) // covariant overriding is still feasible _ <- resolveAndAddImport(rt) _ <- setReturnType(rt) - params <- forEach (op.parameters) { param: Parameter => + params <- forEach(op.parameters) { (param: Parameter) => for { pName <- freshName(names.mangle(param.name)) // must handle case where a particular parameter is not recursive (i.e., is double) pt <- if (param.tpe.isModelBase(domain)) { - findClass(qualifiedBaseDataType(domain.findOperation(op).get) : _ *) + findClass(qualifiedBaseDataType(domain.findOperation(op).get) *) } else { toTargetLanguageType(param.tpe) } @@ -265,29 +274,29 @@ sealed trait Interpreter extends SharedOO { } /** Determines whether it is necessary within DataTypeCase to cast inherited attributes. - * - * If a new operation is defined, then a local DataType Case Class is created, and it will inherit - * baseDomain attributes that need to be cast to current domain - */ - def mustCastToAccess(domain:GenericModel, tpeCase:DataTypeCase) : Boolean = { + * + * If a new operation is defined, then a local DataType Case Class is created, and it will inherit + * baseDomain attributes that need to be cast to current domain + */ + def mustCastToAccess(domain: GenericModel, tpeCase: DataTypeCase): Boolean = { val definingModel = domain.findTypeCase(tpeCase).get !latestModelDefiningNewTypeInterface(domain).beforeOrEqual(definingModel) } /** - * Access attributes using default getter methods. - * - * @param attribute Data Type Case attribute to be accessed - * @return - */ - def attributeInterpreterAccess(att:Attribute, tpeCase: DataTypeCase, domain:GenericModel, baseType:Option[paradigm.syntax.Type]) : Generator[MethodBodyContext, Expression] = { + * Access attributes using default getter methods. + * + * @param attribute Data Type Case attribute to be accessed + * @return + */ + def attributeInterpreterAccess(att: Attribute, tpeCase: DataTypeCase, domain: GenericModel, baseType: Option[paradigm.syntax.Type]): Generator[MethodBodyContext, Expression] = { import ooParadigm.methodBodyCapabilities._ for { thisRef <- selfReference() att_member <- getMember(thisRef, names.mangle(names.instanceNameOf(att))) - casted <- if (att.tpe.isModelBase(domain) && mustCastToAccess(domain, tpeCase)) { // only cast if Exp AND comes from older Exp + casted <- if (att.tpe.isModelBase(domain) && mustCastToAccess(domain, tpeCase)) { // only cast if Exp AND comes from older Exp castObject(baseType.get, att_member) } else { Command.lift[MethodBodyContext, Expression](att_member) @@ -295,8 +304,10 @@ sealed trait Interpreter extends SharedOO { } yield casted } - def makeInterpreterImplementation(domain: GenericModel, tpe: DataType, tpeCase: DataTypeCase, op: Operation, - domainSpecific: EvolutionImplementationProvider[this.type]): Generator[MethodBodyContext, Option[Expression]] = { + def makeInterpreterImplementation( + domain: GenericModel, tpe: DataType, tpeCase: DataTypeCase, op: Operation, + domainSpecific: EvolutionImplementationProvider[this.type] + ): Generator[MethodBodyContext, Option[Expression]] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ @@ -304,28 +315,30 @@ sealed trait Interpreter extends SharedOO { for { _ <- makeInterpreterSignature(domain, op) _ <- if (domain.operationsPresentEarlier(tpeCase).contains(op)) { - setOverride() - } else { - Command.skip[MethodBodyContext] - } + setOverride() + } else { + Command.skip[MethodBodyContext] + } mostSpecificExp <- mostSpecificBaseInterfaceType(domain) - result <- completeImplementation(domain.baseDataType, tpeCase, op, domain, domainSpecific, attributeAccess=attributeInterpreterAccess, baseType=Some(mostSpecificExp)) + result <- completeImplementation(domain.baseDataType, tpeCase, op, domain, domainSpecific, attributeAccess = attributeInterpreterAccess, baseType = Some(mostSpecificExp)) } yield result } /** Generate class for each DataTypeCase and Operation. Be sure to keep extension chain going when there are prior classes available. - * - * package ep.m2; - * - * public class Sub extends ep.m1.Sub implements Exp { - * ... - * } - * - * @return - */ - def makeClassForCase(model: GenericModel, ops: Seq[Operation], tpeCase: DataTypeCase, - domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = { + * + * package ep.m2; + * + * public class Sub extends ep.m1.Sub implements Exp { + * ... + * } + * + * @return + */ + def makeClassForCase( + model: GenericModel, ops: Seq[Operation], tpeCase: DataTypeCase, + domainSpecific: EvolutionImplementationProvider[this.type] + ): Generator[ClassContext, Unit] = { import classCapabilities._ // if an ancestor branch doesn't define parent then add all operations @@ -336,70 +349,74 @@ sealed trait Interpreter extends SharedOO { // always choose the first one. def addPrimaryParent(): Generator[ClassContext, Option[Type]] = { if (!shouldAddParent) { - Command.lift[ClassContext, Option[Type]](Option.empty) + Command.lift[ClassContext, Option[Type]](Option.empty) } else { // go to last model which had defined operation *OR* last model in which this tpeCase is defined. val chosenModel = primaryParent(model, tpeCase) for { - priorType <- findClass(qualifiedDataTypeCase(chosenModel, tpeCase) : _ *) - _ <- resolveAndAddImport(priorType) - _ <- addParent(priorType) - } yield Some(priorType) - } + priorType <- findClass(qualifiedDataTypeCase(chosenModel, tpeCase) *) + _ <- resolveAndAddImport(priorType) + _ <- addParent(priorType) + } yield Some(priorType) } + } // add a parent IF type defined earlier, in ANY of its formers.. def shouldAddParent: Boolean = { model.former.exists(m => m.findTypeCase(tpeCase).isDefined) } - for { // find latest model with operation, since that will be the proper one to use - pt <- findClass(qualifiedBaseDataType(latestModelDefiningNewTypeInterface(model)) : _ *) - _ <- resolveAndAddImport(pt) - _ <- addImplemented(pt) - - primaryParent <- addPrimaryParent() - _ <- if (!shouldAddParent) { - for { - _ <- forEach(tpeCase.attributes) { att => makeField(att) } - } yield () - } else { - Command.skip[ClassContext] - } - - // if super is being used, then you need to cast to Exp - _ <- addConstructor(makeConstructor(tpeCase, !shouldAddParent, useSuper = primaryParent)) - _ <- forEach (ops) { op => addMethod(names.mangle(names.instanceNameOf(op)), makeInterpreterImplementation(model, model.baseDataType, tpeCase, op, domainSpecific)) - } + for { // find latest model with operation, since that will be the proper one to use + pt <- findClass(qualifiedBaseDataType(latestModelDefiningNewTypeInterface(model)) *) + _ <- resolveAndAddImport(pt) + _ <- addImplemented(pt) + + primaryParent <- addPrimaryParent() + _ <- if (!shouldAddParent) { + for { + _ <- forEach(tpeCase.attributes) { att => makeField(att) } + } yield () + } else { + Command.skip[ClassContext] + } + + // if super is being used, then you need to cast to Exp + _ <- addConstructor(makeConstructor(tpeCase, !shouldAddParent, useSuper = primaryParent)) + _ <- forEach(ops) { op => addMethod(names.mangle(names.instanceNameOf(op)), makeInterpreterImplementation(model, model.baseDataType, tpeCase, op, domainSpecific)) + } } yield () } - def generateForOpForType(ops:Seq[Operation], defining:GenericModel, tpeCase:DataTypeCase, domainSpecific: EvolutionImplementationProvider[this.type]) : Generator[ProjectContext, Unit] = { + def generateForOpForType(ops: Seq[Operation], defining: GenericModel, tpeCase: DataTypeCase, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ for { - _ <- addClassToProject(makeClassForCase(defining, ops, tpeCase, domainSpecific), qualifiedDataTypeCase(defining, tpeCase) : _ *) + _ <- addClassToProject(makeClassForCase(defining, ops, tpeCase, domainSpecific), qualifiedDataTypeCase(defining, tpeCase) *) } yield () } - /** Class is generated into 'defining' namespace package. */ - def generateForOp(defining:GenericModel, allTypes:Seq[DataTypeCase], domainSpecific: EvolutionImplementationProvider[this.type]) : Generator[ProjectContext, Unit] = { + /** Class is generated into 'defining' namespace package. */ + def generateForOp(defining: GenericModel, allTypes: Seq[DataTypeCase], domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { for { - _ <- forEach (allTypes) { tpe => { - val prime = primaryParent(defining, tpe) - val necessaryOps = if (defining.typeCases.contains(tpe)) { defining.flatten.ops.distinct} else { defining.ops } - val missing = defining.flatten.ops.distinct.filter(op => (! prime.supports(op)) || op.isProducer(defining)) - val overridden = defining.flatten.ops.distinct.filter(op => { - val selectMap = domainSpecific.evolutionSpecificDependencies(PotentialRequest(defining.baseDataType, tpe, op)) - val hasDependency = domainSpecific.dependencies(PotentialRequest(defining.baseDataType, tpe, op)).isDefined - hasDependency && selectMap.contains(defining) - }) - if ((missing ++ necessaryOps ++ overridden).isEmpty) { - Command.skip[ProjectContext] - } else { - generateForOpForType((missing ++ necessaryOps ++ overridden).distinct, defining, tpe, domainSpecific) // don't forget to include self (defining) - } + _ <- forEach(allTypes) { tpe => { + val prime = primaryParent(defining, tpe) + val necessaryOps = if (defining.typeCases.contains(tpe)) { + defining.flatten.ops.distinct + } else { + defining.ops + } + val missing = defining.flatten.ops.distinct.filter(op => (!prime.supports(op)) || op.isProducer(defining)) + val overridden = defining.flatten.ops.distinct.filter(op => { + val selectMap = domainSpecific.evolutionSpecificDependencies(PotentialRequest(defining.baseDataType, tpe, op)) + val hasDependency = domainSpecific.dependencies(PotentialRequest(defining.baseDataType, tpe, op)).isDefined + hasDependency && selectMap.contains(defining) + }) + if ((missing ++ necessaryOps ++ overridden).isEmpty) { + Command.skip[ProjectContext] + } else { + generateForOpForType((missing ++ necessaryOps ++ overridden).distinct, defining, tpe, domainSpecific) // don't forget to include self (defining) } } + } } yield () } @@ -408,20 +425,21 @@ sealed trait Interpreter extends SharedOO { FindClass(covariantType).interpret(canFindClass) } - def paramType[Context](domain:GenericModel, tpe:DataTypeCase)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] - ) : Generator[Context, Type] = { + def paramType[Context](domain: GenericModel, tpe: DataTypeCase)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] + ): Generator[Context, Type] = { for { cname <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](qualifiedDataTypeCase(domain, tpe)).interpret(canFindClass) _ <- resolveAndAddImport(cname) } yield cname } - def latestModelDefiningNewTypeInterfaceForDataType(domain: GenericModel, tpe:DataTypeCase): GenericModel = { + def latestModelDefiningNewTypeInterfaceForDataType(domain: GenericModel, tpe: DataTypeCase): GenericModel = { val latestDefiningInterface = latestModelDefiningNewTypeInterface(domain) - if (domain == latestDefiningInterface) { // handle merge case as well + if (domain == latestDefiningInterface) { // handle merge case as well domain } else { // find where tpe was defined @@ -429,33 +447,33 @@ sealed trait Interpreter extends SharedOO { val past = domain.inChronologicalOrder val pastWithTpeAndInterfaceDefined = past.filter(p => tpeDefined.beforeOrEqual(p) && latestDefiningInterface.beforeOrEqual(p)) pastWithTpeAndInterfaceDefined.head - } + } } /** Enables mapping each DataType to the designated ep.?.DT class. */ - def registerTypeCases(domain:GenericModel) : Generator[ProjectContext, Unit] = { - import ooParadigm.classCapabilities.{addTypeLookupForMethods => _, addTypeLookupForClasses => _, addTypeLookupForConstructors => _,_} + def registerTypeCases(domain: GenericModel): Generator[ProjectContext, Unit] = { + import ooParadigm.classCapabilities.{addTypeLookupForMethods => _, addTypeLookupForClasses => _, addTypeLookupForConstructors => _, _} import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ import ooParadigm.constructorCapabilities._ import ooParadigm.projectCapabilities._ import paradigm.projectCapabilities._ - for { + for { _ <- forEach(domain.flatten.typeCases) { tpe => { - val updateCurrent = updatedImplementationCurrentDomainByType(domain, tpe) - val tpeDomain = if (updateCurrent.isDefined) { - latestModelDefiningNewTypeInterfaceForDataType(domain, tpe).later(updateCurrent.get) - } else { - latestModelDefiningNewTypeInterfaceForDataType(domain, tpe) - } - for { - _ <- addTypeLookupForMethods(TypeRep.DataType(DataType(tpe.name)), paramType[MethodBodyContext](tpeDomain, tpe)) - _ <- addTypeLookupForClasses(TypeRep.DataType(DataType(tpe.name)), paramType[ClassContext](tpeDomain, tpe)) - _ <- addTypeLookupForConstructors(TypeRep.DataType(DataType(tpe.name)), paramType[ConstructorContext](tpeDomain, tpe)) - } yield () + val updateCurrent = updatedImplementationCurrentDomainByType(domain, tpe) + val tpeDomain = if (updateCurrent.isDefined) { + latestModelDefiningNewTypeInterfaceForDataType(domain, tpe).later(updateCurrent.get) + } else { + latestModelDefiningNewTypeInterfaceForDataType(domain, tpe) } + for { + _ <- addTypeLookupForMethods(DomainTpeRep.DataType(DataType(tpe.name)), paramType[MethodBodyContext](tpeDomain, tpe)) + _ <- addTypeLookupForClasses(DomainTpeRep.DataType(DataType(tpe.name)), paramType[ClassContext](tpeDomain, tpe)) + _ <- addTypeLookupForConstructors(DomainTpeRep.DataType(DataType(tpe.name)), paramType[ConstructorContext](tpeDomain, tpe)) + } yield () + } } - } yield() + } yield () } /** What model is delivered has operations which is essential for the mapping. */ @@ -467,25 +485,25 @@ sealed trait Interpreter extends SharedOO { import paradigm.projectCapabilities._ val baseInterface = baseInterfaceNames(latestModelDefiningNewTypeInterface(model)) - val dtpeRep = TypeRep.DataType(model.baseDataType) + val dtpeRep = DomainTpeRep.DataType(model.baseDataType) for { - _ <- addTypeLookupForMethods(dtpeRep, domainTypeLookup(baseInterface : _*)) - _ <- addTypeLookupForClasses(dtpeRep, domainTypeLookup(baseInterface : _*)) - _ <- addTypeLookupForConstructors(dtpeRep, domainTypeLookup(baseInterface : _*)) + _ <- addTypeLookupForMethods(dtpeRep, domainTypeLookup(baseInterface *)) + _ <- addTypeLookupForClasses(dtpeRep, domainTypeLookup(baseInterface *)) + _ <- addTypeLookupForConstructors(dtpeRep, domainTypeLookup(baseInterface *)) } yield () } /** - * Find the (possibly older) model that actually defines this type case. Now, if some former model defines - * an operation and the model defining the type exists, then return the last. - * - * Look at all past branches and see if any is behind you and select the latest one of those. - */ - def primaryParent(model:GenericModel, tpeCase:DataTypeCase): GenericModel = { + * Find the (possibly older) model that actually defines this type case. Now, if some former model defines + * an operation and the model defining the type exists, then return the last. + * + * Look at all past branches and see if any is behind you and select the latest one of those. + */ + def primaryParent(model: GenericModel, tpeCase: DataTypeCase): GenericModel = { val modelDefiningType = model.findTypeCase(tpeCase) val pastModels = model.former.filter(m => modelDefiningType.getOrElse(m).before(m)).map(m => latestModelDefiningNewTypeInterfaceForDataType(m, tpeCase)) - pastModels.foldLeft(modelDefiningType.get)((latest,m) => latest.later(m)) + pastModels.foldLeft(modelDefiningType.get)((latest, m) => latest.later(m)) } // Have to process models in chronological order to get the Exp mappings properly done. @@ -500,20 +518,20 @@ sealed trait Interpreter extends SharedOO { Command.skip[paradigm.ProjectContext] } else { for { - _ <- registerTypeMapping(domain) // this must be first SO Exp is properly bound within interfaces - _ <- registerTypeCases(domain) // handle DataType classes as well for interpreter + _ <- registerTypeMapping(domain) // this must be first SO Exp is properly bound within interfaces + _ <- registerTypeCases(domain) // handle DataType classes as well for interpreter _ <- if (createLevel) { for { - _ <- addIntermediateInterfaceToProject(domain, domainSpecific) // Exp for each evolution that needs one - _ <- generateForOp(domain, domain.flatten.typeCases, domainSpecific) + _ <- addIntermediateInterfaceToProject(domain, domainSpecific) // Exp for each evolution that needs one + _ <- generateForOp(domain, domain.flatten.typeCases, domainSpecific) } yield () } else { - for { - _ <- generateForOp(domain, typeCasesNotGeneratedYet, domainSpecific) - } yield () + for { + _ <- generateForOp(domain, typeCasesNotGeneratedYet, domainSpecific) + } yield () } - } yield() + } yield () } } @@ -530,7 +548,7 @@ sealed trait Interpreter extends SharedOO { import paradigm.compilationUnitCapabilities._ import paradigm.testCapabilities._ - def implementInner(domain: GenericModel, tests:Seq[TestCase]): Generator[paradigm.ProjectContext, Unit] = { + def implementInner(domain: GenericModel, tests: Seq[TestCase]): Generator[paradigm.ProjectContext, Unit] = { val testCode: Generator[MethodBodyContext, Seq[Expression]] = for { code <- forEach(tests) { @@ -540,7 +558,7 @@ sealed trait Interpreter extends SharedOO { val compUnit = for { _ <- addTestCase(testCode, testName) - } yield() + } yield () val testSuite = for { _ <- addTestSuite(testCaseName(domain), compUnit) @@ -548,14 +566,14 @@ sealed trait Interpreter extends SharedOO { for { _ <- addCompilationUnit(testSuite, testCaseName(domain)) - } yield() + } yield () } for { _ <- forEach(tests.toList) { case (model, tests) => for { - _ <- registerTypeMapping(model) // this must be first SO Exp is properly bound within interfaces - _ <- registerTypeCases(model) // handle DataType classes as well for interpreter + _ <- registerTypeMapping(model) // this must be first SO Exp is properly bound within interfaces + _ <- registerTypeCases(model) // handle DataType classes as well for interpreter _ <- implementInner(model, tests) } yield () } @@ -564,20 +582,27 @@ sealed trait Interpreter extends SharedOO { } object Interpreter { - type WithParadigm[P <: AnyParadigm] = Interpreter { val paradigm: P } - type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] + type WithParadigm[P <: AnyParadigm] = Interpreter {val paradigm: P} + type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] - def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] + def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] (base: P) - (nameProvider: NameProvider[base.syntax.Name], - oo: ObjectOriented.WithBase[base.type], - parametricPolymorphism: ParametricPolymorphism.WithBase[base.type]) - (generics: Generics.WithBase[base.type, oo.type, parametricPolymorphism.type]): Interpreter.WithParadigm[base.type] = - new Interpreter { - val paradigm: base.type = base - val names: NameProvider[paradigm.syntax.Name] = nameProvider - val ooParadigm: oo.type = oo - val polymorphics: parametricPolymorphism.type = parametricPolymorphism - val genericsParadigm: generics.type = generics - } + ( + nameProvider: NameProvider[base.syntax.Name], + oo: ObjectOriented.WithBase[base.type], + parametricPolymorphism: ParametricPolymorphism.WithBase[base.type] + ) + (generics: Generics.WithBase[base.type, oo.type, parametricPolymorphism.type]): Interpreter.WithParadigm[base.type] = { + + case class I( + val paradigm: base.type + )( + val names: NameProvider[paradigm.syntax.Name], + val ooParadigm: oo.type, + val polymorphics: parametricPolymorphism.type + )( + val genericsParadigm: generics.type + ) extends Interpreter + I(base)(nameProvider, oo, parametricPolymorphism)(generics) } +} diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala similarity index 82% rename from core/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala index fd03f242..c8399427 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala @@ -1,16 +1,20 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ +package org.combinators.ep.approach.oo -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, Parameter, TestCase, TypeRep} +/*DI:LI:AD*/ + +import org.combinators.cogen.{TestCase, TypeRep, Command, Understands, NameProvider, AbstractSyntax} +import Command.Generator +import org.combinators.cogen.paradigm.{AddImport, AddTypeLookup, AnyParadigm, Apply, FindClass, Generics, ObjectOriented, ParametricPolymorphism, ResolveImport} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, Parameter, DomainTpeRep} import org.combinators.ep.domain.{GenericModel, abstractions} -import org.combinators.ep.generator.Command.Generator +import org.combinators.ep.domain.extensions._ import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request} -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm._ +import org.combinators.cogen.paradigm.AnyParadigm.syntax.forEach import org.combinators.ep.generator._ /** - * Sufficiently different EP approach that this trait does not extend SharedOO - */ + * Sufficiently different EP approach that this trait does not extend SharedOO + */ trait ObjectAlgebras extends ApproachImplementationProvider { val paradigm: AnyParadigm val ooParadigm: ObjectOriented.WithBase[paradigm.type] @@ -83,7 +87,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // find carrier to use. Note that M3 goes back to M2 (likely because that is when last operation was defined) // Case 1: If a new operation always add a new carrier interface; or // Case 2: If you merge together and there is a new operation from the merging - def carrierToUse(domain:GenericModel) : GenericModel = { + def carrierToUse(domain: GenericModel): GenericModel = { if (domain.ops.nonEmpty) { domain } else { @@ -126,7 +130,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } yield () } - def setOperationMethodSignature(domain: GenericModel, op:Operation): Generator[paradigm.MethodBodyContext, Unit] = { + def setOperationMethodSignature(domain: GenericModel, op: Operation): Generator[paradigm.MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities._ for { parameters <- forEach(op.parameters) { parameter => @@ -145,12 +149,12 @@ trait ObjectAlgebras extends ApproachImplementationProvider { def getSelfSignature(domain: GenericModel): Generator[paradigm.MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities._ for { - returnType <- toTargetLanguageType(TypeRep.DataType(domain.baseDataType)) + returnType <- toTargetLanguageType(DomainTpeRep.DataType(domain.baseDataType)) _ <- setReturnType(returnType) } yield () } - def addOperationCarrierInterface(domain:GenericModel, op:Operation): Generator[paradigm.ProjectContext, Unit] = { + def addOperationCarrierInterface(domain: GenericModel, op: Operation): Generator[paradigm.ProjectContext, Unit] = { // public interface PowBy { // C getSelf(); // C powBy(C other); @@ -163,7 +167,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // Add type parameter for the finalized type _ <- addTypeParameter(ComponentNames.carrier, Command.skip) - _ <- registerTypeMapping(domain) // can only have AFTER declared type parameter + _ <- registerTypeMapping(domain) // can only have AFTER declared type parameter _ <- addAbstractMethod(ComponentNames.getSelf, getSelfSignature(domain)) _ <- addAbstractMethod(names.mangle(names.instanceNameOf(op)), setOperationMethodSignature(domain, op)) @@ -174,7 +178,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } - def addCombinedCarrierInstance(domain:GenericModel): Generator[paradigm.ProjectContext, Unit] = { + def addCombinedCarrierInstance(domain: GenericModel): Generator[paradigm.ProjectContext, Unit] = { // do I add an operation?; or do I add a data type AFTER a producer method? or what about merge WHEN at least one of // your branches HAS a producer method? @@ -201,7 +205,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { def makeOperationClass(): Generator[ooParadigm.ClassContext, Unit] = { - def makeOperationImpl(op:Operation): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { + def makeOperationImpl(op: Operation): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import ooParadigm.methodBodyCapabilities._ import paradigm.methodBodyCapabilities._ for { @@ -225,16 +229,16 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } yield Some(result) } - def getSelfMethod(interfaceType:paradigm.syntax.Type) : Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { + def getSelfMethod(interfaceType: paradigm.syntax.Type): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import ooParadigm.methodBodyCapabilities._ import paradigm.methodBodyCapabilities._ for { _ <- setReturnType(interfaceType) self <- selfReference() - } yield Some(self) + } yield Some(self) } - def makeOperationConstructor(interfaceType:paradigm.syntax.Type): Generator[ooParadigm.ConstructorContext, Unit] = { + def makeOperationConstructor(interfaceType: paradigm.syntax.Type): Generator[ooParadigm.ConstructorContext, Unit] = { import ooParadigm.constructorCapabilities._ import genericsParadigm.constructorCapabilities._ for { @@ -250,7 +254,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { _ <- setParameters(parameters) arguments <- getArguments() - _ <- forEach (arguments.zip(domain.flatten.ops.map(op => ComponentNames.carrierInstance(op)))) { case (arg, att) => + _ <- forEach(arguments.zip(domain.flatten.ops.map(op => ComponentNames.carrierInstance(op)))) { case (arg, att) => for { _ <- initializeField(att, arg._3) } yield () @@ -261,7 +265,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ for { - _ <- registerInstanceTypeMapping(domain) // CRITICAL to do before generating any subsequent artifacts + _ <- registerInstanceTypeMapping(domain) // CRITICAL to do before generating any subsequent artifacts interfaceType <- findClass(names.mangle(names.instanceNameOf(domain)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(domain))) _ <- resolveAndAddImport(interfaceType) @@ -292,7 +296,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } // ////////////////////////////////////////////////////////////////////////////////////////////////////////////// - def addOperationCarrierInstance(domain:GenericModel, op:Operation): Generator[paradigm.ProjectContext, Unit] = { + def addOperationCarrierInstance(domain: GenericModel, op: Operation): Generator[paradigm.ProjectContext, Unit] = { // public final class Eval implements m0.carrier.Eval { // private final double value; // @@ -348,7 +352,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } // ////////////////////////////////////////////////////////////////////////////////////////////////////////////// - def addAlgebraOperation(domain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], op:Operation): Generator[paradigm.ProjectContext, Unit] = { + def addAlgebraOperation(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], op: Operation): Generator[paradigm.ProjectContext, Unit] = { // public final class Eval> implements Signature> { // private final m0.Signature inner; // @@ -364,25 +368,25 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // return new m0.carrier.instance.eval.Add (inner, left.getSelf(), right.getSelf()); // } // } - def setMethodSignature(tpe:DataTypeCase): Generator[paradigm.MethodBodyContext, Unit] = { + def setMethodSignature(tpe: DataTypeCase): Generator[paradigm.MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ for { - baseType <- toTargetLanguageType(TypeRep.DataType(domain.baseDataType)) + baseType <- toTargetLanguageType(DomainTpeRep.DataType(domain.baseDataType)) signature <- forEach(tpe.attributes) { att => toTargetLanguageType(att.tpe) } _ <- setParameters(tpe.attributes.map(att => names.mangle(att.name)).zip(signature)) _ <- setReturnType(baseType) } yield () } - def newOpMethod(tpe:DataTypeCase, carrierType:paradigm.syntax.Type): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { + def newOpMethod(tpe: DataTypeCase, carrierType: paradigm.syntax.Type): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ val newOperations = dataTypeCasesWithNewOperations(domainSpecific, domain).getOrElse(tpe, Set.empty) val possible = if (newOperations.contains(op)) { - domain + domain } else { domainSpecific.evolutionSpecificDependencies(PotentialRequest(domain.baseDataType, tpe, op)).keySet.max((l: GenericModel, r: GenericModel) => { if (l.before(r)) -1 else if (r.before(l)) 1 else 0 @@ -398,16 +402,16 @@ trait ObjectAlgebras extends ApproachImplementationProvider { selfRef <- selfReference() inner <- getMember(selfRef, ComponentNames.inner) - result <- if (latest == domain) { // newly defined....or new operation? + result <- if (latest == domain) { // newly defined....or new operation? for { inst <- findClass(names.mangle(names.instanceNameOf(latest)), ComponentNames.pkgCarrier, ComponentNames.pkgInstance, - names.mangle(names.instanceNameOf(op)), names.mangle(names.conceptNameOf(tpe))) + names.mangle(names.instanceNameOf(op)), names.mangle(names.conceptNameOf(tpe))) _ <- resolveAndAddImport(inst) instGeneric <- applyType(inst, Seq(carrierType)) // when accessing ANEW, since you have to construct - processedAtts <- forEach (tpe.attributes.zip(attributeValues)) { case (att, attv) => + processedAtts <- forEach(tpe.attributes.zip(attributeValues)) { case (att, attv) => for { - pt <- if (att.tpe == TypeRep.DataType(domain.baseDataType)) { + pt <- if (att.tpe == DomainTpeRep.DataType(domain.baseDataType)) { for { getSelfMethod <- getMember(attv._3, ComponentNames.getSelf) result <- apply(getSelfMethod, Seq.empty) @@ -431,9 +435,9 @@ trait ObjectAlgebras extends ApproachImplementationProvider { factoryAtt <- getMember(selfRef, names.mangle(names.instanceNameOf(defined))) // when accessing ANEW, since you have to construct - processedAtts <- forEach (tpe.attributes.zip(attributeValues)) { case (att, attv) => + processedAtts <- forEach(tpe.attributes.zip(attributeValues)) { case (att, attv) => for { - pt <- if (att.tpe == TypeRep.DataType(domain.baseDataType)) { + pt <- if (att.tpe == DomainTpeRep.DataType(domain.baseDataType)) { for { getSelfMethod <- getMember(attv._3, ComponentNames.getSelf) result <- apply(getSelfMethod, Seq.empty) @@ -451,7 +455,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } yield Some(result) } - def makeAlgebraConstructor(signatureTpe:paradigm.syntax.Type, carrierTpe:paradigm.syntax.Type): Generator[ooParadigm.ConstructorContext, Unit] = { + def makeAlgebraConstructor(signatureTpe: paradigm.syntax.Type, carrierTpe: paradigm.syntax.Type): Generator[ooParadigm.ConstructorContext, Unit] = { import ooParadigm.constructorCapabilities._ import genericsParadigm.constructorCapabilities._ @@ -468,7 +472,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { _ <- forEach(domain.former.collect { case dom if dom.supports(op) => latestDomainWithAlgebraOperation(dom, domainSpecific, op) }.distinct) { dom => { for { - _ <- if (!dom.equals(domain)) { // only if not the same + _ <- if (!dom.equals(domain)) { // only if not the same for { // m3.algebra.PrettyPrint clazz <- findClass(names.mangle(names.instanceNameOf(dom)), ComponentNames.pkgAlgebra, names.mangle(names.conceptNameOf(op))) @@ -501,13 +505,14 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // Needs to add all prior dependencies, because the algebra operation pulls together all previous carriers with // all constraints on dependent operations. diTypes <- forEach(domain.flatten.typeCases.distinct.flatMap(tpeCase => - domainSpecific.dependencies(PotentialRequest(domain.baseDataType, tpeCase, op)).getOrElse(Set.empty) - ).distinct) { dop => { + domainSpecific.dependencies(PotentialRequest(domain.baseDataType, tpeCase, op)).getOrElse(Set.empty) + ).distinct) { dop => { for { ditype <- findClass(names.mangle(names.instanceNameOf(domain.findOperation(dop).get)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(dop))) _ <- resolveAndAddImport(ditype) } yield ditype - }} + } + } _ <- addTypeParameter(carrierTypeParam, makeTypeParameter(interfaceType, diTypes)) tpeParams <- getTypeArguments() @@ -526,20 +531,20 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // if in MERGE case, need to add oldNNN for each operation that was defined on a previous branch, we need // oldNNN to record that branch _ <- forEach(domain.former.collect { case dom if dom.supports(op) => latestDomainWithAlgebraOperation(dom, domainSpecific, op) }.distinct) { - dom => { - for { - // m3.algebra.PrettyPrint - clazz <- findClass(names.mangle(names.instanceNameOf(dom)), ComponentNames.pkgAlgebra, names.mangle(names.conceptNameOf(op))) - _ <- resolveAndAddImport(clazz) - appliedClazz <- applyType(clazz, Seq(tpeParams.head)) - _ <- addField(names.mangle(names.instanceNameOf(dom)), appliedClazz) - } yield () - } - } + dom => { + for { + // m3.algebra.PrettyPrint + clazz <- findClass(names.mangle(names.instanceNameOf(dom)), ComponentNames.pkgAlgebra, names.mangle(names.conceptNameOf(op))) + _ <- resolveAndAddImport(clazz) + appliedClazz <- applyType(clazz, Seq(tpeParams.head)) + _ <- addField(names.mangle(names.instanceNameOf(dom)), appliedClazz) + } yield () + } + } _ <- addConstructor(makeAlgebraConstructor(signatureTpeCarrierGeneric, tpeParams.head)) - _ <- forEach (domain.flatten.typeCases) { tpe => + _ <- forEach(domain.flatten.typeCases) { tpe => for { _ <- addMethod(names.mangle(names.instanceNameOf(tpe)), newOpMethod(tpe, tpeParams.head), isPublic = true) } yield () @@ -557,24 +562,24 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } // ////////////////////////////////////////////////////////////////////////////////////////////////////////////// - def addCombinedAlgebra(domain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[paradigm.ProjectContext, Unit] = { -// public class M0 implements Signature { -// private final Eval eval = new Eval(this); -// -// @Override public m0.carrier.M0 lit(double value) { -// return new m0.carrier.instance.M0(eval.lit(value)); -// } -// -// @Override public m0.carrier.M0 add(m0.carrier.M0 left, m0.carrier.M0 right) { -// return new m0.carrier.instance.M0(eval.add(left, right)); -// } -// } - - def setMethodSignature(tpe:DataTypeCase): Generator[paradigm.MethodBodyContext, Unit] = { + def addCombinedAlgebra(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[paradigm.ProjectContext, Unit] = { + // public class M0 implements Signature { + // private final Eval eval = new Eval(this); + // + // @Override public m0.carrier.M0 lit(double value) { + // return new m0.carrier.instance.M0(eval.lit(value)); + // } + // + // @Override public m0.carrier.M0 add(m0.carrier.M0 left, m0.carrier.M0 right) { + // return new m0.carrier.instance.M0(eval.add(left, right)); + // } + // } + + def setMethodSignature(tpe: DataTypeCase): Generator[paradigm.MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ - val latest = carrierToUse(domain) // latestModelDefiningNewTypeInterface + val latest = carrierToUse(domain) // latestModelDefiningNewTypeInterface for { carrierInstanceType <- findClass(names.mangle(names.instanceNameOf(latest)), @@ -585,21 +590,21 @@ trait ObjectAlgebras extends ApproachImplementationProvider { _ <- resolveAndAddImport(carrierType) signature <- forEach(tpe.attributes) { att => - if (att.tpe.isModelBase(latest)) { // operhaps domain still? - Command.lift[paradigm.MethodBodyContext, paradigm.syntax.Type](carrierType) - } else { - for { - signatureType <- toTargetLanguageType(att.tpe) - _ <- resolveAndAddImport(signatureType) - } yield signatureType - } + if (att.tpe.isModelBase(latest)) { // operhaps domain still? + Command.lift[paradigm.MethodBodyContext, paradigm.syntax.Type](carrierType) + } else { + for { + signatureType <- toTargetLanguageType(att.tpe) + _ <- resolveAndAddImport(signatureType) + } yield signatureType } + } _ <- setParameters(tpe.attributes.map(att => names.mangle(att.name)).zip(signature)) _ <- setReturnType(carrierType) } yield () } - def newOpMethod(tpe:DataTypeCase): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { + def newOpMethod(tpe: DataTypeCase): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ @@ -613,8 +618,9 @@ trait ObjectAlgebras extends ApproachImplementationProvider { attributeValues <- getArguments() selfRef <- selfReference() - processedAtts <- forEach (tpe.attributes.zip(attributeValues)) { case (att, attv) => - Command.lift[paradigm.MethodBodyContext, paradigm.syntax.Expression](attv._3) } + processedAtts <- forEach(tpe.attributes.zip(attributeValues)) { case (att, attv) => + Command.lift[paradigm.MethodBodyContext, paradigm.syntax.Expression](attv._3) + } args <- forEach(domain.flatten.ops) { op => for { @@ -645,7 +651,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { _ <- resolveAndAddImport(opType) carrierType <- findClass(names.mangle(names.instanceNameOf(defined)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(defined))) _ <- resolveAndAddImport(carrierType) - appliedType <- applyType(opType, Seq(carrierType)) + appliedType <- applyType(opType, Seq(carrierType)) thisRef <- selfReference() result <- instantiateObject(appliedType, Seq(thisRef)) // should be appliedType (not opType) @@ -681,12 +687,12 @@ trait ObjectAlgebras extends ApproachImplementationProvider { _ <- resolveAndAddImport(opType) appliedType <- applyType(opType, Seq(carrierType)) _ <- addField(names.mangle(names.instanceNameOf(op)), appliedType) - } yield() + } yield () } _ <- addConstructor(makeAlgebraConstructor()) - _ <- forEach (domain.flatten.typeCases) { tpe => + _ <- forEach(domain.flatten.typeCases) { tpe => for { _ <- addMethod(names.mangle(names.instanceNameOf(tpe)), newOpMethod(tpe), isPublic = true) } yield () @@ -700,7 +706,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // ////////////////////////////////////////////////////////////////////////////////////////////////////////////// - def addSignatureInterface(domain:GenericModel): Generator[paradigm.ProjectContext, Unit] = { + def addSignatureInterface(domain: GenericModel): Generator[paradigm.ProjectContext, Unit] = { // public interface Signature { // Carrier lit(double value); // Carrier add(Carrier left, Carrier right); @@ -774,8 +780,8 @@ trait ObjectAlgebras extends ApproachImplementationProvider { tpeParam <- findClass(names.mangle(names.instanceNameOf(domain)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(domain))) _ <- resolveAndAddImport(tpeParam) - _ <- forEach (domain.flatten.ops) { op => - val location = domain.findOperation(op).get //must always exist + _ <- forEach(domain.flatten.ops) { op => + val location = domain.findOperation(op).get //must always exist for { carrierType <- findClass(names.mangle(names.instanceNameOf(location)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(op))) @@ -799,9 +805,9 @@ trait ObjectAlgebras extends ApproachImplementationProvider { //////////////////////////////////////////////////////////////// /** Map data type cases to operations that require a new implementation in the given domain model. - * Will only contain data type cases which have been newly introduced in at least one of the ancestor branches - * or require an update because of missing/overwritten operations or merging of multiple branches. - */ + * Will only contain data type cases which have been newly introduced in at least one of the ancestor branches + * or require an update because of missing/overwritten operations or merging of multiple branches. + */ def dataTypeCasesWithNewOperations(evolutionImplementationProvider: EvolutionImplementationProvider[this.type], domain: GenericModel): Map[DataTypeCase, Set[Operation]] = { val flatDomain = domain.flatten val allDataTypeCases = flatDomain.typeCases.toSet @@ -878,7 +884,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { def latestDependenciesForOp(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], op: Operation)(tpeCases: Seq[DataTypeCase] = domain.flatten.typeCases.distinct): Seq[Operation] = { tpeCases.distinct.flatMap(tpeCase => { val dependencies = domainSpecific.evolutionSpecificDependencies(PotentialRequest(domain.baseDataType, tpeCase, op)) - val dependenciesDeclaredBeforeCurrentDomain = dependencies.filterKeys(d => d.beforeOrEqual(domain)) + val dependenciesDeclaredBeforeCurrentDomain = dependencies.view.filterKeys(d => d.beforeOrEqual(domain)) val latestDependencies = dependenciesDeclaredBeforeCurrentDomain .max((l: (GenericModel, Set[Operation]), r: (GenericModel, Set[Operation])) => { if (l._1.before(r._1)) -1 else if (r._1.before(l._1)) 1 else 0 @@ -887,7 +893,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { }).distinct } - def latestDomainWithAlgebraOperation(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], op:Operation) : GenericModel = { + def latestDomainWithAlgebraOperation(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], op: Operation): GenericModel = { // Find all domains with an EIP that implements op for any type case val domainsImplementingOp = domain.flatten.typeCases.flatMap(tpeCase => domainSpecific.evolutionSpecificDependencies(PotentialRequest(domain.baseDataType, tpeCase, op)).keySet @@ -903,7 +909,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { val orderedImplementers = domainsImplementingOp.distinct .filter(d => d.beforeOrEqual(domain)) // filter to make sure we are before the current domain (we are not interested in later EIPs) - .sorted(cmp) + .sorted((x, y) => cmp(x, y)) .reverse // Are there two non-comparable ancestors l, r that haven't been merged by a third m which is past both? Then we are @@ -915,31 +921,31 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } orderedImplementers.head -// LEAVE THIS HERE TO SHOW WHAT WAS REPLACED -// // find type case where domainSpecific says you are implemented here. -// val result = domain.flatten.typeCases.map(tpeCase => -// // are we implementing or overriding. -// domainSpecific.applicableIn( -// forApproach = this, -// potentialRequest = PotentialRequest(domain.baseDataType, tpeCase, op), -// currentModel = domain -// ) -// ) -// -// val implementedHere = result.contains(Some(domain)) -// if (implementedHere) { -// domain -// } else { -// val pastOnes = domain.former.map(m => latestDomainWithAlgebraOperation(m, domainSpecific, op)).distinct -// if (domain.isDomainBase || pastOnes.size > 1) { -// domain -// } else { -// pastOnes.head -// } -// } + // LEAVE THIS HERE TO SHOW WHAT WAS REPLACED + // // find type case where domainSpecific says you are implemented here. + // val result = domain.flatten.typeCases.map(tpeCase => + // // are we implementing or overriding. + // domainSpecific.applicableIn( + // forApproach = this, + // potentialRequest = PotentialRequest(domain.baseDataType, tpeCase, op), + // currentModel = domain + // ) + // ) + // + // val implementedHere = result.contains(Some(domain)) + // if (implementedHere) { + // domain + // } else { + // val pastOnes = domain.former.map(m => latestDomainWithAlgebraOperation(m, domainSpecific, op)).distinct + // if (domain.isDomainBase || pastOnes.size > 1) { + // domain + // } else { + // pastOnes.head + // } + // } } - def makeTypeParameter(tpe:paradigm.syntax.Type, dependentOpTypes:Seq[paradigm.syntax.Type]) : Generator[polymorphics.TypeParameterContext, Unit] = { + def makeTypeParameter(tpe: paradigm.syntax.Type, dependentOpTypes: Seq[paradigm.syntax.Type]): Generator[polymorphics.TypeParameterContext, Unit] = { import genericsParadigm.typeParameterCapabilities._ // needs to add more lower bounds for dependent operations @@ -948,7 +954,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { itype <- applyType(tpe, Seq(carrierType)) _ <- addLowerBound(itype) - _ <- forEach (dependentOpTypes) { ditype => { + _ <- forEach(dependentOpTypes) { ditype => { for { dtype <- applyType(ditype, Seq(carrierType)) _ <- addLowerBound(dtype) @@ -960,7 +966,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { ////////////////////////////////////////////////////////////////////////////////////// - def addOperationCarrierInstanceForDataTypeCase( domainSpecific: EvolutionImplementationProvider[this.type], domain:GenericModel, dt:DataTypeCase, op:Operation): Generator[paradigm.ProjectContext, Unit] = { + def addOperationCarrierInstanceForDataTypeCase(domainSpecific: EvolutionImplementationProvider[this.type], domain: GenericModel, dt: DataTypeCase, op: Operation): Generator[paradigm.ProjectContext, Unit] = { // public final class Add> implements MultBy { // private final i1.Signature algebra; // private final C left; @@ -996,9 +1002,9 @@ trait ObjectAlgebras extends ApproachImplementationProvider { _ <- setReturnType(returnType) selfRef <- selfReference() selfMember <- getMember(selfRef, ComponentNames.getSelf) - selfCall <- apply (selfMember, Seq.empty) + selfCall <- apply(selfMember, Seq.empty) - dtElements <- forEach (dt.attributes) { param => + dtElements <- forEach(dt.attributes) { param => for { paramField <- getMember(selfRef, names.mangle(param.name)) } yield (param, paramField) @@ -1019,19 +1025,19 @@ trait ObjectAlgebras extends ApproachImplementationProvider { //_ <- debug(domain.name + " replaced with " + properModel.name + " for operation " + op.name + " & dt=" + dt.name) result <- domainSpecific.logic(this)( - ReceivedRequest( - domain.baseDataType, - dt, - selfCall, - dt.attributes.zip(dtElements.map(_._2)).toMap, - Request(op, op.parameters.zip(args.map(_._3)).toMap), - Some(properModel) - ) - ) + ReceivedRequest( + domain.baseDataType, + dt, + selfCall, + dt.attributes.zip(dtElements.map(_._2)).toMap, + Request(op, op.parameters.zip(args.map(_._3)).toMap), + Some(properModel) + ) + ) } yield result } - def getSelfMethod(interfaceType:paradigm.syntax.Type) : Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { + def getSelfMethod(interfaceType: paradigm.syntax.Type): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import ooParadigm.methodBodyCapabilities._ import paradigm.methodBodyCapabilities._ for { @@ -1045,15 +1051,16 @@ trait ObjectAlgebras extends ApproachImplementationProvider { for { p <- getMember(self, names.mangle(att.name)) } yield p - }} + } + } // algebra.lit(value); invocation <- apply(dtMethod, params) - } yield Some(invocation) + } yield Some(invocation) } - def makeOperationConstructor(tpeParam:paradigm.syntax.Type): Generator[ooParadigm.ConstructorContext, Unit] = { + def makeOperationConstructor(tpeParam: paradigm.syntax.Type): Generator[ooParadigm.ConstructorContext, Unit] = { import ooParadigm.constructorCapabilities._ import genericsParadigm.constructorCapabilities._ for { @@ -1065,7 +1072,8 @@ trait ObjectAlgebras extends ApproachImplementationProvider { tpe <- toTargetLanguageType(att.tpe) name <- freshName(names.mangle(att.name)) } yield (name, tpe) - }} + } + } attParamName <- freshName(ComponentNames.algebraAtt) _ <- setParameters((attParamName, appliedSignatureTpe) +: params) arguments <- getArguments() @@ -1090,13 +1098,14 @@ trait ObjectAlgebras extends ApproachImplementationProvider { for { ditype <- findClass(names.mangle(names.instanceNameOf(domain.findOperation(dop).get)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(dop))) _ <- resolveAndAddImport(ditype) - } yield ditype - }} + } yield ditype + } + } _ <- addTypeParameter(carrierTypeParam, makeTypeParameter(interfaceType, diTypes)) tpeParams <- getTypeArguments() - _ <- registerCarrierInstanceTypeMapping(domain, tpeParams) // CRITICAL to do before generating any subsequent artifacts + _ <- registerCarrierInstanceTypeMapping(domain, tpeParams) // CRITICAL to do before generating any subsequent artifacts _ <- addMethod(ComponentNames.getSelf, getSelfMethod(tpeParams.head)) @@ -1113,7 +1122,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { for { tpe <- toTargetLanguageType(att.tpe) _ <- addField(names.mangle(names.instanceNameOf(att)), tpe) - } yield() + } yield () } _ <- addConstructor(makeOperationConstructor(tpeParams.head)) _ <- addMethod(names.mangle(names.instanceNameOf(op)), makeOperationImpl()) @@ -1132,7 +1141,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { for { _ <- addSignatureInterface(domain) - _ <- addCombinedAlgebra(domain, domainSpecific) // need domainSpecific to find appropriate algebra.Op artifact + _ <- addCombinedAlgebra(domain, domainSpecific) // need domainSpecific to find appropriate algebra.Op artifact // only necessary if operation is new _ <- forEach(domain.ops) { op => @@ -1147,17 +1156,17 @@ trait ObjectAlgebras extends ApproachImplementationProvider { // formers that define different ones; if just one former that does it, we don't need to (though later it is // necessary to take this into account when searching for the past algebra.operation class _ <- forEach(domain.flatten.ops.filter(op => latestDomainWithAlgebraOperation(domain, domainSpecific, op) == domain)) { op => - addAlgebraOperation(domain, domainSpecific, op) + addAlgebraOperation(domain, domainSpecific, op) } _ <- forEach(dataTypeCasesWithNewOperations(domainSpecific, domain).toSeq) { case (dataTypeCase, ops) => for { - _ <- forEach (ops.toSeq){ op => + _ <- forEach(ops.toSeq) { op => for { _ <- addOperationCarrierInstanceForDataTypeCase(domainSpecific, domain, dataTypeCase, op) - } yield() + } yield () } - } yield() + } yield () } // case 1: if just doing new data types, no need for new carrier @@ -1183,29 +1192,30 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } // must be the case that op is valid in model - def registerInstanceTypeMappingOperation(model: GenericModel, tpeParams:Seq[paradigm.syntax.Type], op:Operation): Generator[ooParadigm.ClassContext, Unit] = { + def registerInstanceTypeMappingOperation(model: GenericModel, tpeParams: Seq[paradigm.syntax.Type], op: Operation): Generator[ooParadigm.ClassContext, Unit] = { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ - import genericsParadigm.constructorCapabilities._ // NEEDED, despite IntelliJ editor + import genericsParadigm.constructorCapabilities._ // NEEDED, despite IntelliJ editor import paradigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ import ooParadigm.constructorCapabilities._ import ooParadigm.methodBodyCapabilities._ - val dtpeRep = TypeRep.DataType(model.baseDataType) + val dtpeRep = DomainTpeRep.DataType(model.baseDataType) // Operation must be discoverable already for this model assert(model.findOperation(op).nonEmpty) - def properCarrierType[Context](implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], - canApplyType: Understands[Context, Apply[paradigm.syntax.Type,paradigm.syntax.Type,paradigm.syntax.Type]] - ): Generator[Context, paradigm.syntax.Type] = { + def properCarrierType[Context]( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], + canApplyType: Understands[Context, Apply[paradigm.syntax.Type, paradigm.syntax.Type, paradigm.syntax.Type]] + ): Generator[Context, paradigm.syntax.Type] = { for { baseInterfaceType <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](Seq(names.mangle(names.instanceNameOf(model.findOperation(op).get)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(op)))).interpret(canFindClass) - _ <- resolveAndAddImport(baseInterfaceType)(canResolveImport,canAddImport) - appliedInterfaceType <- Apply[paradigm.syntax.Type,paradigm.syntax.Type,paradigm.syntax.Type](baseInterfaceType, tpeParams).interpret(canApplyType) + _ <- resolveAndAddImport(baseInterfaceType)(canResolveImport, canAddImport) + appliedInterfaceType <- Apply[paradigm.syntax.Type, paradigm.syntax.Type, paradigm.syntax.Type](baseInterfaceType, tpeParams).interpret(canApplyType) } yield appliedInterfaceType } @@ -1216,25 +1226,26 @@ trait ObjectAlgebras extends ApproachImplementationProvider { } yield () } - def registerCarrierInstanceTypeMapping(model: GenericModel, tpeParams:Seq[paradigm.syntax.Type]): Generator[ooParadigm.ClassContext, Unit] = { + def registerCarrierInstanceTypeMapping(model: GenericModel, tpeParams: Seq[paradigm.syntax.Type]): Generator[ooParadigm.ClassContext, Unit] = { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ - import genericsParadigm.constructorCapabilities._ // NEEDED, despite IntelliJ editor + import genericsParadigm.constructorCapabilities._ // NEEDED, despite IntelliJ editor import paradigm.methodBodyCapabilities._ import polymorphics.methodBodyCapabilities._ import ooParadigm.constructorCapabilities._ import ooParadigm.methodBodyCapabilities._ - val dtpeRep = TypeRep.DataType(model.baseDataType) + val dtpeRep = DomainTpeRep.DataType(model.baseDataType) for { - _ <- addTypeLookupForMethods(dtpeRep, Command.lift[paradigm.MethodBodyContext,paradigm.syntax.Type](tpeParams.head)) - _ <- addTypeLookupForClasses(dtpeRep, Command.lift[ooParadigm.ClassContext,paradigm.syntax.Type](tpeParams.head)) - _ <- addTypeLookupForConstructors(dtpeRep, Command.lift[ooParadigm.ConstructorContext,paradigm.syntax.Type](tpeParams.head)) + _ <- addTypeLookupForMethods(dtpeRep, Command.lift[paradigm.MethodBodyContext, paradigm.syntax.Type](tpeParams.head)) + _ <- addTypeLookupForClasses(dtpeRep, Command.lift[ooParadigm.ClassContext, paradigm.syntax.Type](tpeParams.head)) + _ <- addTypeLookupForConstructors(dtpeRep, Command.lift[ooParadigm.ConstructorContext, paradigm.syntax.Type](tpeParams.head)) } yield () } // Generic registration of ep..carrier. in Class and Project context - def registerInstanceTypeMapping[Context](model: GenericModel)(implicit + def registerInstanceTypeMapping[Context](model: GenericModel)( + implicit canAddTypeLookupForMethods: Understands[Context, AddTypeLookup[paradigm.MethodBodyContext, paradigm.syntax.Type]], canAddTypeLookupForClasses: Understands[Context, AddTypeLookup[ooParadigm.ClassContext, paradigm.syntax.Type]], canAddTypeLookupForConstructors: Understands[Context, AddTypeLookup[ooParadigm.ConstructorContext, paradigm.syntax.Type]], @@ -1244,16 +1255,17 @@ trait ObjectAlgebras extends ApproachImplementationProvider { import paradigm.methodBodyCapabilities._ import ooParadigm.constructorCapabilities._ import ooParadigm.methodBodyCapabilities._ - val dtpeRep = TypeRep.DataType(model.baseDataType) + val dtpeRep = DomainTpeRep.DataType(model.baseDataType) - def properCarrierType[Context](implicit + def properCarrierType[Context]( + implicit canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] ): Generator[Context, paradigm.syntax.Type] = { for { baseInterfaceType <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](Seq(names.mangle(names.instanceNameOf(model)), ComponentNames.pkgCarrier, names.mangle(names.conceptNameOf(model)))).interpret(canFindClass) - _ <- resolveAndAddImport(baseInterfaceType)(canResolveImport,canAddImport) + _ <- resolveAndAddImport(baseInterfaceType)(canResolveImport, canAddImport) } yield baseInterfaceType } @@ -1268,7 +1280,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { import ooParadigm.classCapabilities._ import genericsParadigm.classCapabilities._ - val dtpeRep = TypeRep.DataType(model.baseDataType) + val dtpeRep = DomainTpeRep.DataType(model.baseDataType) for { carrierType <- getTypeArguments().map(tpeArgs => tpeArgs.head) @@ -1284,7 +1296,7 @@ trait ObjectAlgebras extends ApproachImplementationProvider { import paradigm.testCapabilities._ import ooParadigm.projectCapabilities._ - def addAlgebraFieldAutoinitialized(model:GenericModel) : Generator[paradigm.TestContext, Unit] = { + def addAlgebraFieldAutoinitialized(model: GenericModel): Generator[paradigm.TestContext, Unit] = { import ooParadigm.testCapabilities._ for { tpe <- findClass(names.mangle(names.instanceNameOf(model)), ComponentNames.pkgAlgebra, names.mangle(names.conceptNameOf(model))) @@ -1302,14 +1314,14 @@ trait ObjectAlgebras extends ApproachImplementationProvider { for { code <- forEach(tests) { test => - testImplementationProvider.test(this)(test) + testImplementationProvider.test(this)(test) } } yield code.flatten } val compUnit = for { - _ <- addAlgebraFieldAutoinitialized(model) // made this autoinitialized using default constructor new CLASS() + _ <- addAlgebraFieldAutoinitialized(model) // made this autoinitialized using default constructor new CLASS() // add test case first _ <- addTestCase(testCode, testName) @@ -1335,18 +1347,22 @@ object ObjectAlgebras { type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] - (base: P) - ( - nameProvider: NameProvider[base.syntax.Name], - oo: ObjectOriented.WithBase[base.type], - params: ParametricPolymorphism.WithBase[base.type] - ) - (generics: Generics.WithBase[base.type, oo.type, params.type]): ObjectAlgebras.WithParadigm[base.type] = - new ObjectAlgebras { - val paradigm: base.type = base - val ooParadigm: oo.type = oo - val polymorphics: params.type = params - val genericsParadigm: generics.type = generics - val names: NameProvider[paradigm.syntax.Name] = nameProvider - } + (base: P) + ( + nameProvider: NameProvider[base.syntax.Name], + oo: ObjectOriented.WithBase[base.type], + params: ParametricPolymorphism.WithBase[base.type] + ) + (generics: Generics.WithBase[base.type, oo.type, params.type]): ObjectAlgebras.WithParadigm[base.type] = { + case class OA( + override val paradigm: base.type + )( + override val names: NameProvider[paradigm.syntax.Name], + override val ooParadigm: oo.type, + override val polymorphics: params.type + )( + override val genericsParadigm: generics.type + ) extends ObjectAlgebras + OA(base)(nameProvider, oo, params)(generics) + } } \ No newline at end of file diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala similarity index 95% rename from core/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala index 2855085e..b2601a9c 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala @@ -2,9 +2,10 @@ package org.combinators.ep.approach.oo /*DI:LI:AD*/ import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions.{Attribute, DataType, DataTypeCase, Operation, Parameter} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.ObjectOriented +import org.combinators.cogen.Command +import Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm.syntax.forEach +import org.combinators.cogen.paradigm.ObjectOriented import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} /** diff --git a/approach/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala new file mode 100644 index 00000000..46337924 --- /dev/null +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala @@ -0,0 +1,384 @@ +package org.combinators.ep.approach.oo /*DI:LI:AD*/ + +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm.syntax._ +import org.combinators.cogen.paradigm.control.Imperative +import org.combinators.cogen.paradigm.ffi.{Exceptions, Strings} +import org.combinators.cogen.paradigm.{AnyParadigm, ObjectOriented} +import org.combinators.cogen.{AbstractSyntax, InstanceRep, NameProvider, TypeRep} +import org.combinators.ep.domain.GenericModel +import org.combinators.ep.domain.abstractions._ +import org.combinators.ep.generator._ +import org.combinators.ep.generator.communication._ + +// Needed for EpCoGen extensions from CoGen +import org.combinators.ep.domain.extensions._ + +/** + * Runtime Dispatch + * + * Have to decide whether to use side effects or Generics. This current implementation uses the Visitor generics + * approach, which can be adopted by different object oriented languages. + */ +trait RuntimeDispatch extends SharedOO with OperationAsClass { + val paradigm: AnyParadigm + val ooParadigm: ObjectOriented.WithBase[paradigm.type] + val names: NameProvider[paradigm.syntax.Name] + + val impParadigm: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type] + val exceptions: Exceptions.WithBase[paradigm.MethodBodyContext, paradigm.type] + val strings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type] + + import ooParadigm._ + import paradigm._ + import syntax._ + + val expParameter: String = "exp" + + /** + * Instantiates an instance of the domain object. + * + * Same implementation for OO as for visitor. + * + * new Add(new Lit(new Double(1.0)), new Lit(new Double(2.0))) + */ + def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] = { + import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ + for { + // access the constructor for the class associated with type case and invoke constructors with arguments. + rt <- findClass(names.mangle(names.conceptNameOf(tpeCase))) + _ <- resolveAndAddImport(rt) + res <- instantiateObject(rt, args) + } yield res + } + + /** + * Dispatch creates a new dispatch object and invokes operation with attributes. + * + * new Eval().eval(e.getLeft()) + new Eval().eval(e.getRight()) + * + * @param message the SendRequest + * @return + */ + def dispatch(message: SendRequest[Expression]): Generator[MethodBodyContext, Expression] = { + import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ + val op = message.request.op + for { + + // the operation is encoded in its own class, which we must find to determine the visitor type + opType <- findClass(names.mangle(names.conceptNameOf(op))) // Each class is based on Operation + _ <- resolveAndAddImport(opType) // gives resulting import statement (if needed) + + // construct the Operation object for the given type (and parameters) + dispatcher <- instantiateObject(opType, op.parameters.map(param => message.request.arguments(param))) + + // In the 'message.to' expression, invoke the 'accept' method with a visitor argument + method <- getMember(dispatcher, names.mangle(names.instanceNameOf(op))) // things which are code-generated use the '<-' handles unpacking results + rt <- toTargetLanguageType(message.request.op.returnType) + _ <- resolveAndAddImport(rt) + + // apply to method with the visitor, resulting in the expression + result <- apply(method, Seq(message.to)) // has to be Seq[] just for syntax of calling the method + } yield result + } + + /** + * + * {{{ + * public op.returnType ???(rt e); + * }}} + * + * @return + */ + def makeOperationSignature(paramType: Type, op: Operation): Generator[MethodBodyContext, Unit] = { + import paradigm.methodBodyCapabilities._ + for { + + // this returns mangled visitTypeParameter name and gets list of all type parameters, for which there is only one, so we get head + rt <- toTargetLanguageType(op.returnType) + _ <- resolveAndAddImport(rt) + _ <- setReturnType(rt) + + expParam <- freshName(names.mangle(expParameter)) + _ <- setParameters(Seq((expParam, paramType))) // a pair (name,type) of only one sequence + } yield () + } + + /** + * Create an operation that dispatches accordingly to all known data types to helper method. + * {{{ + * public RT op(Exp exp) { + * if (exp instanceof Lit) { + *return _eval((Lit) exp); + *} + * + *if (exp instanceof Add) { + *return _eval((Add) exp); + *} + * + * } + * }}} + * + * @return + */ + def makeDispatchingOperation(model: GenericModel, op: Operation): Generator[ClassContext, Unit] = { + def ifStmt(): Generator[MethodBodyContext, Option[Expression]] = { + import exceptions.exceptionCapabilities._ + import impParadigm.imperativeCapabilities._ + import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ + + for { + _ <- forEach(model.flatten.typeCases) { tpe => + for { + tpeCase <- findClass(names.mangle(names.conceptNameOf(tpe))) + _ <- resolveAndAddImport(tpeCase) + args <- getArguments() + condExpr <- instanceOfType(tpeCase, args.head._3) + self <- selfReference() + innerFunction <- getMember(self, names.addPrefix("_", names.mangle(names.instanceNameOf(op)))) + + casted <- castObject(tpeCase, args.head._3) + result <- apply(innerFunction, Seq(casted)) + blockReturn <- returnStmt(result) + ifs <- ifThenElse(condExpr, addBlockDefinitions(Seq(blockReturn)), Seq.empty) + _ <- addBlockDefinitions(Seq(ifs)) + } yield None + } + + expr <- this.reify(InstanceRep(TypeRep.String)("Missing Subclass Case!")) + throws <- raise(expr) + _ <- addBlockDefinitions(Seq(throws)) + } yield None + } + + val makeBody: Generator[MethodBodyContext, Option[Expression]] = { + import paradigm.methodBodyCapabilities._ + + for { + rt <- toTargetLanguageType(DomainTpeRep.DataType(model.baseDataType)) + _ <- resolveAndAddImport(rt) + + _ <- makeOperationSignature(rt, op) + _ <- ifStmt() + } yield None + } + + import ooParadigm.classCapabilities._ + addMethod(names.mangle(names.instanceNameOf(op)), makeBody) + } + + /** + * Each operation is placed in its own class, with a 'visit' method for each known data type. + * + * Uses the generic 'operationClass' capability to create the structure of the class. + * + * {{{ + * class Eval { } + * + * public Double op(Exp e) { + * + * } + * + * public Double _op(Lit e) { + * return e.getValue(); + * } + * + * public Double _op(Add e) { + * return op(e.left) + op(e.right) + * } + * } + * }}} + * + * @param domain Model for which all types are to be incorporated + * @param op The operation whose implementation is needed + * @param domainSpecific The EIP to gain access to the logic + * @return The one invoking this method must be sure to add this class to project. + */ + def makeOperationImplementation( + domain: GenericModel, op: Operation, + domainSpecific: EvolutionImplementationProvider[this.type] + ): Generator[ClassContext, Unit] = { + import ooParadigm.classCapabilities._ + + for { + // this will ultimately invoke makeTypeCaseImplementation for all necessary typecases + _ <- operationClass(names.addPrefix("_", names.mangle(names.instanceNameOf(op))), op, domain, domain.flatten.typeCases.distinct, domain.baseDataType, domainSpecific) + + returnTpe <- toTargetLanguageType(op.returnType) + _ <- resolveAndAddImport(returnTpe) + + _ <- makeDispatchingOperation(domain, op) + } yield () + } + + /** Just the skeleton class holding structure, since operations are designated to their own classes. */ + def makeDerived(parentType: DataType, tpeCase: DataTypeCase): Generator[ProjectContext, Unit] = { + import ooParadigm.projectCapabilities._ + val makeClass: Generator[ClassContext, Unit] = { + import ooParadigm.classCapabilities._ + for { + parent <- toTargetLanguageType(DomainTpeRep.DataType(parentType)) + _ <- resolveAndAddImport(parent) + _ <- addParent(parent) + _ <- forEach(tpeCase.attributes) { att => makeField(att) } + _ <- addConstructor(makeConstructor(tpeCase)) + _ <- forEach(tpeCase.attributes) { att => makeGetter(att) } + + } yield () + } + addClassToProject(makeClass, names.mangle(names.conceptNameOf(tpeCase))) + } + + /** + * Define the base class for Exp which must contain the accept method as an abstract method. + * + * {{{ + * public abstract class Exp { + * public abstract R accept(Visitor v); + * } + * }}} + * + * @param tpe The DataType that needs a Base Class. + * @return + */ + def makeBase(tpe: DataType): Generator[ProjectContext, Unit] = { + import ooParadigm.projectCapabilities._ + + val makeClass: Generator[ClassContext, Unit] = { + import ooParadigm.classCapabilities._ + for { + _ <- setAbstract() + } yield () + } + + // adds the 'Exp' class, with a single accept method + addClassToProject(makeClass, names.mangle(names.conceptNameOf(tpe))) + } + + def targetExp: Generator[MethodBodyContext, Expression] = { + import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ + + for { + expRef <- getArguments().map(_.head._3) + } yield expRef + } + + /** Make a method body for each operation, which dispatches to appropriate method + * + * {{{ + * public class Eval { + *public Eval() { } + *public Double _eval(Add exp) { + *return (new ep.Eval().eval(exp.getLeft()) + new ep.Eval().eval(exp.getRight())); + *} + *} + * }}} + * + * A runtime dispatcher will direct to appropriate _op() method from the op() method in class + * + * @param tpe Base Data Type. + * @param tpeCase The Data Type Case. + * @param op The operation at play. + * @param domainSpecific The EIP which contains the logic. + * @return Full implementation. + */ + override def makeTypeCaseImplementation( + tpe: DataType, tpeCase: DataTypeCase, op: Operation, model: GenericModel, + domainSpecific: EvolutionImplementationProvider[this.type] + ): Generator[MethodBodyContext, Option[Expression]] = { + import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ + for { + returnType <- toTargetLanguageType(op.returnType) + _ <- resolveAndAddImport(returnType) + + ptype <- findClass(names.mangle(names.conceptNameOf(tpeCase))) + _ <- resolveAndAddImport(ptype) + _ <- makeOperationSignature(ptype, op) + + result <- completeImplementationFromParameters(tpe, tpeCase, op, model, domainSpecific, target = targetExp, attributeAccess = attributeDispatchAccess) + } yield result + } + + /** + * Access attributes using default getter methods via argument to method, exp + * + * @param attribute Data Type Case attribute to be accessed + * @return + */ + def attributeDispatchAccess(attribute: Attribute, tpeCase: DataTypeCase, domain: GenericModel, baseType: Option[paradigm.syntax.Type]): Generator[MethodBodyContext, Expression] = { + import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ + + for { + expRef <- getArguments().map(_.head._3) + getterMethod <- getMember(expRef, getterName(attribute)) + getterCall <- apply(getterMethod, Seq.empty) + } yield getterCall + } + + /** + * The Runtime Dispatch approach is defined as follows + * + * 1. Make the base class (for the domain) + * 2. For each of the operations (in flattened set) create an operation class that has + * dynamic runtime checks to dispatch to appropriate method + * 3. For each data type (in flatted set) create data type class to hold information + * + * @param gdomain Top-level domain. + * @param domainSpecific Its corresponding EIP. + * @return The whole project. + */ + def implement(gdomain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { + import ooParadigm.projectCapabilities._ + import paradigm.projectCapabilities._ + + val flat = gdomain.linearize.flatten + for { + _ <- strings.enable() + _ <- exceptions.enable() + _ <- registerTypeMapping(flat) + _ <- domainSpecific.initialize(this) + + // singular Exp abstract class + _ <- makeBase(flat.baseDataType) + + _ <- forEach(flat.typeCases) { tpeCase => + makeDerived(flat.baseDataType, tpeCase) + } + _ <- forEach(flat.ops) { op => + addClassToProject(makeOperationImplementation(gdomain, op, domainSpecific), names.mangle(names.conceptNameOf(op))) + } + } yield () + } +} + +object RuntimeDispatch { + type WithParadigm[P <: AnyParadigm] = RuntimeDispatch {val paradigm: P} + type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] + + def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] + (base: P) + ( + nameProvider: NameProvider[base.syntax.Name], + impParadigmProvider: Imperative.WithBase[base.MethodBodyContext, base.type], + stringsProvider: Strings.WithBase[base.MethodBodyContext, base.type], + exceptionsProvider: Exceptions.WithBase[base.MethodBodyContext, base.type], + oo: ObjectOriented.WithBase[base.type] + ): RuntimeDispatch.WithParadigm[base.type] = { + case class RD( + override val paradigm: base.type + )( + override val names: NameProvider[paradigm.syntax.Name], + override val impParadigm: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + override val strings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], + override val exceptions: Exceptions.WithBase[paradigm.MethodBodyContext, paradigm.type], + override val ooParadigm: oo.type + ) extends RuntimeDispatch + RD(base)(nameProvider, impParadigmProvider, stringsProvider, exceptionsProvider, oo) + } +} diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala similarity index 96% rename from core/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala index 44639203..791e2814 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala @@ -1,12 +1,16 @@ package org.combinators.ep.approach.oo /*DI:LI:AD*/ +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm.syntax.forEach +import org.combinators.cogen.paradigm.{FindClass, ObjectOriented} +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.generator.Command.Generator import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request} -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.{FindClass, ObjectOriented} -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider, Understands} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} + +// Needed for EpCoGen extensions to CoGen +import org.combinators.ep.domain.extensions._ trait SharedOO extends ApproachImplementationProvider { val ooParadigm: ObjectOriented.WithBase[paradigm.type] @@ -15,10 +19,6 @@ trait SharedOO extends ApproachImplementationProvider { import paradigm._ import syntax._ - - import paradigm._ - import syntax._ - /** * Default registration for findClass, which works with each registerTypeMapping for the different approaches. * @@ -39,13 +39,12 @@ trait SharedOO extends ApproachImplementationProvider { * This enables target-language classes to be retrieved from within the code generator in the Method, Class or Constructor contexts. */ def registerTypeMapping(domain: GenericModel): Generator[ProjectContext, Unit] = { - import paradigm.projectCapabilities.addTypeLookupForMethods - import ooParadigm.methodBodyCapabilities.canFindClassInMethod - import ooParadigm.projectCapabilities.addTypeLookupForClasses - import ooParadigm.projectCapabilities.addTypeLookupForConstructors import ooParadigm.classCapabilities.canFindClassInClass import ooParadigm.constructorCapabilities.canFindClassInConstructor - val dtpeRep = TypeRep.DataType(domain.baseDataType) + import ooParadigm.methodBodyCapabilities.canFindClassInMethod + import ooParadigm.projectCapabilities.{addTypeLookupForClasses, addTypeLookupForConstructors} + import paradigm.projectCapabilities.addTypeLookupForMethods + val dtpeRep = DomainTpeRep.DataType(domain.baseDataType) for { _ <- addTypeLookupForMethods(dtpeRep, domainTypeLookup(domain.baseDataType)) _ <- addTypeLookupForClasses(dtpeRep, domainTypeLookup(domain.baseDataType)) @@ -83,7 +82,7 @@ trait SharedOO extends ApproachImplementationProvider { rt <- toTargetLanguageType(op.returnType) _ <- resolveAndAddImport(rt) _ <- setReturnType(rt) - params <- forEach (op.parameters) { param: Parameter => + params <- forEach (op.parameters) { (param: Parameter) => for { pt <- toTargetLanguageType(param.tpe) _ <- resolveAndAddImport(pt) @@ -108,7 +107,7 @@ trait SharedOO extends ApproachImplementationProvider { val orderedImplementers = domainsImplementingOp.toSeq .filter(d => d.beforeOrEqual(domain)) // filter to make sure we are before the current domain (we are not interested in later EIPs) - .sorted(cmp) + .sorted((x, y) => cmp(x, y)) .reverse // Are there two non-comparable ancestors l, r that haven't been merged by a third m which is past both? Then we are @@ -132,8 +131,8 @@ trait SharedOO extends ApproachImplementationProvider { * @return */ def attributeGetterAccess(attribute:Attribute, tpeCase: DataTypeCase, domain:GenericModel, baseType:Option[paradigm.syntax.Type]) : Generator[MethodBodyContext, Expression] = { - import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ for { thisRef <- selfReference() @@ -210,8 +209,8 @@ trait SharedOO extends ApproachImplementationProvider { attributeAccess:(Attribute, DataTypeCase, GenericModel, Option[paradigm.syntax.Type]) => Generator[MethodBodyContext, Expression] = attributeDirectAccess, baseType: Option[paradigm.syntax.Type] = None): Generator[MethodBodyContext, Option[Expression]] = { - import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ val properModel = latestModelDefiningOperatorClass(domain, tpeCase, op, domainSpecific).get @@ -361,7 +360,7 @@ trait SharedOO extends ApproachImplementationProvider { import ooParadigm.constructorCapabilities._ for { - params <- forEach (tpeCase.attributes) { att: Attribute => + params <- forEach (tpeCase.attributes) { (att: Attribute) => for { at <- toTargetLanguageType(att.tpe) pName <- freshName(names.mangle(names.instanceNameOf(att))) diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/TODO.txt b/approach/src/main/scala/org/combinators/ep/approach/oo/TODO.txt similarity index 100% rename from core/src/main/scala/org/combinators/ep/approach/oo/TODO.txt rename to approach/src/main/scala/org/combinators/ep/approach/oo/TODO.txt diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala similarity index 63% rename from core/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala index 59533a69..553c1191 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala @@ -1,18 +1,25 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ +package org.combinators.ep.approach.oo +/*DI:LI:AD*/ + +import org.combinators.cogen.{Command, NameProvider, AbstractSyntax} +import Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm.syntax._ +import org.combinators.cogen.paradigm.{AnyParadigm, ObjectOriented} import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions._ import org.combinators.ep.generator._ import org.combinators.ep.generator.communication._ -import org.combinators.ep.generator.paradigm._ -import Command._ -import AnyParadigm.syntax._ -trait Traditional extends SharedOO { // this had been sealed. not sure why +// Needed for EpCoGen extensions to CoGen +import org.combinators.ep.domain.extensions._ + + +trait Traditional extends SharedOO { // this had been sealed. not sure why val ooParadigm: ObjectOriented.WithBase[paradigm.type] - import paradigm._ import ooParadigm._ + import paradigm._ import syntax._ def dispatch(message: SendRequest[Expression]): Generator[MethodBodyContext, Expression] = { @@ -25,8 +32,8 @@ trait Traditional extends SharedOO { // this had been sealed. not sure why } def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] = { - import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ + import paradigm.methodBodyCapabilities._ for { rt <- findClass(names.mangle(names.conceptNameOf(tpeCase))) @@ -37,12 +44,12 @@ trait Traditional extends SharedOO { // this had been sealed. not sure why } /** - * When a DataTypeCase forms a class (given a sequence of operations) this function does the heavy lifting. - * - * A constructor is generated, using [[makeConstructor]]. Fields are generates, using [[makeField]]. Each - * operation is embedded as a method within each class, using [[makeImplementation]] - */ - def makeDerived(tpe: DataType, tpeCase: DataTypeCase, ops: Seq[Operation], domain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { + * When a DataTypeCase forms a class (given a sequence of operations) this function does the heavy lifting. + * + * A constructor is generated, using [[makeConstructor]]. Fields are generates, using [[makeField]]. Each + * operation is embedded as a method within each class, using [[makeImplementation]] + */ + def makeDerived(tpe: DataType, tpeCase: DataTypeCase, ops: Seq[Operation], domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { import ooParadigm.projectCapabilities._ def fullImplementation(op: Operation): Generator[MethodBodyContext, Option[Expression]] = { @@ -55,14 +62,14 @@ trait Traditional extends SharedOO { // this had been sealed. not sure why val makeClass: Generator[ClassContext, Unit] = { import classCapabilities._ for { - pt <- toTargetLanguageType(TypeRep.DataType(tpe)) + pt <- toTargetLanguageType(DomainTpeRep.DataType(tpe)) _ <- resolveAndAddImport(pt) _ <- addParent(pt) - _ <- forEach (tpeCase.attributes) { att => makeField(att) } + _ <- forEach(tpeCase.attributes) { att => makeField(att) } _ <- addConstructor(makeConstructor(tpeCase)) - _ <- forEach (ops) { op => - addMethod(names.mangle(names.instanceNameOf(op)), fullImplementation(op)) - } + _ <- forEach(ops) { op => + addMethod(names.mangle(names.instanceNameOf(op)), fullImplementation(op)) + } } yield () } addClassToProject(makeClass, names.mangle(names.conceptNameOf(tpeCase))) @@ -88,25 +95,27 @@ trait Traditional extends SharedOO { // this had been sealed. not sure why _ <- domainSpecific.initialize(this) _ <- makeBase(flatDomain.baseDataType, flatDomain.ops) - _ <- forEach (flatDomain.typeCases.distinct) { tpeCase => - makeDerived(flatDomain.baseDataType, tpeCase, flatDomain.ops, gdomain, domainSpecific) - } + _ <- forEach(flatDomain.typeCases.distinct) { tpeCase => + makeDerived(flatDomain.baseDataType, tpeCase, flatDomain.ops, gdomain, domainSpecific) + } } yield () } } object Traditional { - type WithParadigm[P <: AnyParadigm] = Traditional { val paradigm: P } + type WithParadigm[P <: AnyParadigm] = Traditional {val paradigm: P} type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] - (base: P) - (nameProvider: NameProvider[base.syntax.Name], + (base: P) + ( + nameProvider: NameProvider[base.syntax.Name], oo: ObjectOriented.WithBase[base.type] - ): Traditional.WithParadigm[base.type] = - new Traditional { - override val paradigm: base.type = base - override val names: NameProvider[paradigm.syntax.Name] = nameProvider - override val ooParadigm: ObjectOriented.WithBase[paradigm.type] = oo - } + ): Traditional.WithParadigm[base.type] = { + case class TD(override val paradigm: base.type)( + override val names: NameProvider[paradigm.syntax.Name], + override val ooParadigm: ObjectOriented.WithBase[paradigm.type] + ) extends Traditional + TD(base)(nameProvider, oo) + } } diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/TriviallyClean.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/TriviallyClean.scala similarity index 75% rename from core/src/main/scala/org/combinators/ep/approach/oo/TriviallyClean.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/TriviallyClean.scala index a3a3c8a7..9ac28c51 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/TriviallyClean.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/TriviallyClean.scala @@ -1,15 +1,21 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ +package org.combinators.ep.approach.oo +/*DI:LI:AD*/ + +import org.combinators.cogen.{TestCase, TypeRep, Command, NameProvider, AbstractSyntax, Understands} +import org.combinators.cogen.paradigm.{AddImport, AnyParadigm, FindClass, ObjectOriented, ResolveImport} import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.{GenericModel, abstractions} -import org.combinators.ep.generator.Command._ import org.combinators.ep.generator._ import org.combinators.ep.generator.communication._ -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax._ -import org.combinators.ep.generator.paradigm._ +import org.combinators.cogen.paradigm.AnyParadigm.syntax._ +import Command.Generator import scala.annotation.tailrec +// Need EpCoGen extensions to CoGen +import org.combinators.ep.domain.extensions._ + trait TriviallyClean extends SharedOO { val paradigm: AnyParadigm val ooParadigm: ObjectOriented.WithBase[paradigm.type] @@ -35,18 +41,18 @@ trait TriviallyClean extends SharedOO { case class FinalizedDataTypeCase(tpeCase: DataTypeCase) extends TypeRep /** - * Instantiating an instance of the data type. - * - * public void testTest() { - * org.junit.Assert.assertTrue("", Double.valueOf(new finalized.Add(new Lit(1.0), new Lit(2.0)).eval()).equals(3.0)); - * org.junit.Assert.assertTrue("", Double.valueOf(new Lit(5.0).eval()).equals(5.0)); - * } - * - * @param baseTpe Top-level Exp - * @param tpeCase Specific data type case for object to be instantiated - * @param args necessary arguments to the constructor - * @return - */ + * Instantiating an instance of the data type. + * + * public void testTest() { + * org.junit.Assert.assertTrue("", Double.valueOf(new finalized.Add(new Lit(1.0), new Lit(2.0)).eval()).equals(3.0)); + * org.junit.Assert.assertTrue("", Double.valueOf(new Lit(5.0).eval()).equals(5.0)); + * } + * + * @param baseTpe Top-level Exp + * @param tpeCase Specific data type case for object to be instantiated + * @param args necessary arguments to the constructor + * @return + */ def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] = { import ooParadigm.methodBodyCapabilities._ import paradigm.methodBodyCapabilities._ @@ -59,10 +65,11 @@ trait TriviallyClean extends SharedOO { } /** Find the most specific Exp class currently at play, given the current domain. */ - def mostSpecificBaseInterfaceType[Context](domain: GenericModel)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] + def mostSpecificBaseInterfaceType[Context](domain: GenericModel)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] ): Generator[Context, paradigm.syntax.Type] = { val _latestDomainDefiningInterface = latestModelDefiningInterface(domain) @@ -74,10 +81,11 @@ trait TriviallyClean extends SharedOO { } /** Find the most specific Exp class currently at play, given the current domain. */ - def givenBaseInterfaceType[Context](domain: GenericModel, tpe:DataTypeCase)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] + def givenBaseInterfaceType[Context](domain: GenericModel, tpe: DataTypeCase)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]] ): Generator[Context, paradigm.syntax.Type] = { for { @@ -108,12 +116,12 @@ trait TriviallyClean extends SharedOO { } } - def newerTypeCasesSinceInterface(domain:GenericModel) : Seq[DataTypeCase] = { + def newerTypeCasesSinceInterface(domain: GenericModel): Seq[DataTypeCase] = { val lastExp = latestModelDefiningInterface(domain) val toRemove = lastExp.flatten.typeCases // will have to allow those IN the interface extension as well - domain.flatten.typeCases.filterNot(tpe => toRemove.contains(tpe)).seq + domain.flatten.typeCases.filterNot(tpe => toRemove.contains(tpe)) } // binary methods need fixing since EARLIER evolutions would use EARLIER types @@ -137,14 +145,14 @@ trait TriviallyClean extends SharedOO { } _ <- setParameters(operation.parameters.map(param => names.mangle(param.name)).zip(signature)) - returnType <- if (operation.returnType.isModelBase(domain)) { + returnType <- if (operation.returnType.isModelBase(domain)) { Command.lift[paradigm.MethodBodyContext, paradigm.syntax.Type](returnTypeInterface) } else { - for { + for { signatureType <- toTargetLanguageType(operation.returnType) _ <- resolveAndAddImport(signatureType) } yield signatureType - } + } _ <- setReturnType(returnType) } yield () } @@ -159,7 +167,7 @@ trait TriviallyClean extends SharedOO { for { // add all parents (now made unique) - _<- forEach(existingParentDomains) { ancestor => + _ <- forEach(existingParentDomains) { ancestor => for { parentTypeInterface <- mostSpecificBaseInterfaceType(ancestor) _ <- addParent(parentTypeInterface) @@ -181,28 +189,29 @@ trait TriviallyClean extends SharedOO { } yield () } - import ooParadigm.projectCapabilities._ - addClassToProject(makeNewTypeInterface(), names.mangle(names.instanceNameOf(domain)), names.mangle(names.conceptNameOf(domain.baseDataType))) + import ooParadigm.projectCapabilities._ + addClassToProject(makeNewTypeInterface(), names.mangle(names.instanceNameOf(domain)), names.mangle(names.conceptNameOf(domain.baseDataType))) } - def mostSpecificModel(domain:GenericModel, dataTypeCase:DataTypeCase) : Option[GenericModel] = { + def mostSpecificModel(domain: GenericModel, dataTypeCase: DataTypeCase): Option[GenericModel] = { val potential = dataTypeCasesWithNewOperations(domain) val haveChanged = potential.exists(pair => pair._1 == dataTypeCase && pair._2.nonEmpty) if (domain.findTypeCase(dataTypeCase).isDefined) { - if (haveChanged) { - Some(domain) - } else { - domain.findTypeCase(dataTypeCase) - } + if (haveChanged) { + Some(domain) } else { - None + domain.findTypeCase(dataTypeCase) } + } else { + None + } } - def mostSpecificTypeCaseInterface[Context](domain: GenericModel, dataTypeCase:DataTypeCase)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], + def mostSpecificTypeCaseInterface[Context](domain: GenericModel, dataTypeCase: DataTypeCase)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], ): Generator[Context, Option[paradigm.syntax.Type]] = { val potential = dataTypeCasesWithNewOperations(domain) @@ -232,20 +241,21 @@ trait TriviallyClean extends SharedOO { if (_latestModelDefiningDataTypeCaseInterface.isEmpty) { Command.lift[Context, Option[paradigm.syntax.Type]](Option.empty) } else { - for { - dataTypeCaseInterface <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](Seq(names.mangle(names.instanceNameOf(_latestModelDefiningDataTypeCaseInterface.get)), names.mangle(names.conceptNameOf(dataTypeCase)))).interpret(canFindClass) - _ <- resolveAndAddImport(dataTypeCaseInterface) - } yield Some(dataTypeCaseInterface) - } + for { + dataTypeCaseInterface <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](Seq(names.mangle(names.instanceNameOf(_latestModelDefiningDataTypeCaseInterface.get)), names.mangle(names.conceptNameOf(dataTypeCase)))).interpret(canFindClass) + _ <- resolveAndAddImport(dataTypeCaseInterface) + } yield Some(dataTypeCaseInterface) + } } - def finalizedTypeCaseClass[Context](domain: GenericModel, dataTypeCase:DataTypeCase)(implicit - canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], - canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], - canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], + def finalizedTypeCaseClass[Context](domain: GenericModel, dataTypeCase: DataTypeCase)( + implicit + canFindClass: Understands[Context, FindClass[paradigm.syntax.Name, paradigm.syntax.Type]], + canResolveImport: Understands[Context, ResolveImport[paradigm.syntax.Import, paradigm.syntax.Type]], + canAddImport: Understands[Context, AddImport[paradigm.syntax.Import]], ): Generator[Context, paradigm.syntax.Type] = { @tailrec - def latestDeclaringTypeCase(model:GenericModel): GenericModel = { + def latestDeclaringTypeCase(model: GenericModel): GenericModel = { if (model.typeCases.contains(dataTypeCase)) { model } else { @@ -264,15 +274,15 @@ trait TriviallyClean extends SharedOO { val optimized = domain.optimizations.exists(pair => pair._1 == dataTypeCase) - val toUse= if (optimized) { + val toUse = if (optimized) { domain } else { _latestModelDefiningDataTypeCaseInterface } for { - dataTypeCaseInterface <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](Seq(names.mangle(names.instanceNameOf(toUse)), ComponentNames.finalizedPackage, names.mangle(names.conceptNameOf(dataTypeCase)))).interpret(canFindClass) - _ <- resolveAndAddImport(dataTypeCaseInterface) - } yield dataTypeCaseInterface + dataTypeCaseInterface <- FindClass[paradigm.syntax.Name, paradigm.syntax.Type](Seq(names.mangle(names.instanceNameOf(toUse)), ComponentNames.finalizedPackage, names.mangle(names.conceptNameOf(dataTypeCase)))).interpret(canFindClass) + _ <- resolveAndAddImport(dataTypeCaseInterface) + } yield dataTypeCaseInterface } def setAttributeGetterSignature(domain: GenericModel, attribute: abstractions.Attribute): Generator[paradigm.MethodBodyContext, Unit] = { @@ -290,26 +300,26 @@ trait TriviallyClean extends SharedOO { } def makeOperationImplementation( - domainSpecific: EvolutionImplementationProvider[this.type], - domain: GenericModel, - dataTypeCase: DataTypeCase, - operation: Operation - ): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { + domainSpecific: EvolutionImplementationProvider[this.type], + domain: GenericModel, + dataTypeCase: DataTypeCase, + operation: Operation + ): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import paradigm.methodBodyCapabilities._ import ooParadigm.methodBodyCapabilities._ for { _ <- setOperationMethodSignature(domain, operation) _ <- if (domain.operationsPresentEarlier(dataTypeCase).contains(operation)) { - setOverride() - } else { - Command.skip[paradigm.MethodBodyContext] - } + setOverride() + } else { + Command.skip[paradigm.MethodBodyContext] + } // Use more specific base type for 'isDomainBase' attribute types baseInterfaceType <- mostSpecificBaseInterfaceType(domain) - result <- completeImplementation(domain.baseDataType, dataTypeCase, operation, domain, domainSpecific, attributeAccess=attributeGetterAccess, baseType=Some(baseInterfaceType)) + result <- completeImplementation(domain.baseDataType, dataTypeCase, operation, domain, domainSpecific, attributeAccess = attributeGetterAccess, baseType = Some(baseInterfaceType)) } yield result } @@ -326,8 +336,8 @@ trait TriviallyClean extends SharedOO { val pastWithExp = if (domain.former.length > 1) domain.former.filter(dm => dm == latestModelDefiningInterface(dm)) else Seq.empty val merged = pastWithExp.flatMap(m => dataTypeCasesWithNewOperations(m)).groupBy(_._1) - .map(triple => triple._1 -> triple._2.flatMap(pm => pm._2)) - .filter(entry => entry._2.nonEmpty) + .map(triple => triple._1 -> triple._2.flatMap(pm => pm._2)) + .filter(entry => entry._2.nonEmpty) // whenever a new Exp is defined, MUST duplicate logic for all producer methods; incorporate into logic below val addedExp = domain == lastExp @@ -350,7 +360,7 @@ trait TriviallyClean extends SharedOO { .map(entry => (entry._1, entry._2.flatMap(pair => pair._2).toSet)) } - def makeNewTypeCaseInterface(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], newDataTypeCase:DataTypeCase, newOperations:Set[Operation]) : Generator[ooParadigm.ClassContext, Unit] = { + def makeNewTypeCaseInterface(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type], newDataTypeCase: DataTypeCase, newOperations: Set[Operation]): Generator[ooParadigm.ClassContext, Unit] = { import ooParadigm.classCapabilities._ for { @@ -367,7 +377,7 @@ trait TriviallyClean extends SharedOO { } else { Command.skip[ooParadigm.ClassContext] } - } yield() + } yield () } // Add abstract getters if defined here @@ -375,7 +385,7 @@ trait TriviallyClean extends SharedOO { addAbstractMethod(getterName(attribute), setAttributeGetterSignature(domain, attribute)) } - _ <- forEach (newerTypeCasesSinceInterface(domain)) { tpeCase => + _ <- forEach(newerTypeCasesSinceInterface(domain)) { tpeCase => addTypeLookupForMethods(FinalizedDataTypeCase(tpeCase), finalizedTypeCaseClass(domain, tpeCase)( canFindClass = ooParadigm.methodBodyCapabilities.canFindClassInMethod, canResolveImport = paradigm.methodBodyCapabilities.canResolveImportInMethod, @@ -385,7 +395,7 @@ trait TriviallyClean extends SharedOO { // Add methods for new operations // In Methods we use the least specific type (ep.Exp) to refer to the domain base type. - _ <- addTypeLookupForMethods(TypeRep.DataType(domain.baseDataType), mostSpecificBaseInterfaceType(domain)( + _ <- addTypeLookupForMethods(DomainTpeRep.DataType(domain.baseDataType), mostSpecificBaseInterfaceType(domain)( canFindClass = ooParadigm.methodBodyCapabilities.canFindClassInMethod, canResolveImport = paradigm.methodBodyCapabilities.canResolveImportInMethod, canAddImport = paradigm.methodBodyCapabilities.canAddImportInMethodBody @@ -415,7 +425,7 @@ trait TriviallyClean extends SharedOO { } for { - _ <- forEach(finalMap.toList) { case (dataTypeCase,newOperations) => + _ <- forEach(finalMap.toList) { case (dataTypeCase, newOperations) => if (newOperations.nonEmpty) { addClassToProject(makeNewTypeCaseInterface(domain, domainSpecific, dataTypeCase, newOperations), names.mangle(names.instanceNameOf(domain)), names.mangle(names.conceptNameOf(dataTypeCase))) } else { @@ -461,7 +471,7 @@ trait TriviallyClean extends SharedOO { def addFinalizedTypeCaseClassesIfNecessary(domain: GenericModel): Generator[paradigm.ProjectContext, Unit] = { - def makeNewFinalizedTypeCaseClass(newDataTypeCase: DataTypeCase) : Generator[ooParadigm.ClassContext, Unit] = { + def makeNewFinalizedTypeCaseClass(newDataTypeCase: DataTypeCase): Generator[ooParadigm.ClassContext, Unit] = { import ooParadigm.classCapabilities._ for { @@ -474,18 +484,18 @@ trait TriviallyClean extends SharedOO { } _ <- forEach(domain.former) { former => - val latest = mostSpecificModel(domain, newDataTypeCase).getOrElse(former) // fall back to former if not present - val here = former.lastModelWithOperation.foldLeft(latest)((defined, model) => defined.later(model)) - for { - // find where it was last defined (can only be one), and that's the one to import *OR* if a new operation was defined in between. - formerInterface <- mostSpecificTypeCaseInterface(here, newDataTypeCase) - _ <- if (formerInterface.isDefined) { - addImplemented(formerInterface.get) - } else { - Command.skip[ooParadigm.ClassContext] - } - } yield () - } + val latest = mostSpecificModel(domain, newDataTypeCase).getOrElse(former) // fall back to former if not present + val here = former.lastModelWithOperation.foldLeft(latest)((defined, model) => defined.later(model)) + for { + // find where it was last defined (can only be one), and that's the one to import *OR* if a new operation was defined in between. + formerInterface <- mostSpecificTypeCaseInterface(here, newDataTypeCase) + _ <- if (formerInterface.isDefined) { + addImplemented(formerInterface.get) + } else { + Command.skip[ooParadigm.ClassContext] + } + } yield () + } // Add fields and their getters baseTypeInterface <- mostSpecificBaseInterfaceType(domain) @@ -504,7 +514,7 @@ trait TriviallyClean extends SharedOO { } yield () } - val haveChanged = dataTypeCasesWithNewOperations(domain).filter(pair => pair._2.nonEmpty).keys.toSeq + val haveChanged = dataTypeCasesWithNewOperations(domain).filter(pair => pair._2.nonEmpty).keys.toSeq import ooParadigm.projectCapabilities._ for { @@ -518,17 +528,17 @@ trait TriviallyClean extends SharedOO { def implementRecursive(domain: GenericModel): Generator[paradigm.ProjectContext, Unit] = { for { - _ <- registerTypeMapping(domain) // handle DataType classes + _ <- registerTypeMapping(domain) // handle DataType classes _ <- if (domain == latestModelDefiningInterface(domain)) { for { - _ <- addNewTypeInterface(domain) // Exp for each evolution that needs one + _ <- addNewTypeInterface(domain) // Exp for each evolution that needs one } yield () } else { Command.skip[paradigm.ProjectContext] } - _ <- addDataTypeCaseInterfaces(domain, domainSpecific) // DataTypeCase interfaces as needed - _ <- addFinalizedTypeCaseClassesIfNecessary(domain) // Finalized classes + _ <- addDataTypeCaseInterfaces(domain, domainSpecific) // DataTypeCase interfaces as needed + _ <- addFinalizedTypeCaseClassesIfNecessary(domain) // Finalized classes _ <- forEach(domain.former.filterNot(p => p.isDomainBase)) { ancestor => implementRecursive(ancestor) } } yield () @@ -545,29 +555,28 @@ trait TriviallyClean extends SharedOO { import ooParadigm.classCapabilities.canFindClassInClass import ooParadigm.constructorCapabilities.canFindClassInConstructor import ooParadigm.methodBodyCapabilities.canFindClassInMethod + import org.combinators.cogen.paradigm.FindClass import paradigm.projectCapabilities._ - import org.combinators.ep.generator.Understands - import org.combinators.ep.generator.paradigm.FindClass // all type cases that were defined AFTER last Exp need to be registered val flat = domain.flatten - val ordered = domain.inChronologicalOrder.reverse // ensures proper topological ordering + val ordered = domain.inChronologicalOrder.reverse // ensures proper topological ordering val seqs = flat.typeCases.map(tpe => (tpe, ordered.find(m => dataTypeCasesWithNewOperations(m).exists(pair => pair._1 == tpe)).get)) - val dtpeRep = TypeRep.DataType(domain.baseDataType) + val dtpeRep = DomainTpeRep.DataType(domain.baseDataType) for { - _ <- forEach (seqs) { case (tpeCase, model) => // passes on capabilities so it knows which generators to use... - for { + _ <- forEach(seqs) { case (tpeCase, model) => // passes on capabilities so it knows which generators to use... + for { _ <- addTypeLookupForMethods(FinalizedDataTypeCase(tpeCase), finalizedTypeCaseClass(model, tpeCase)(canFindClass = ooParadigm.methodBodyCapabilities.canFindClassInMethod, canAddImport = paradigm.methodBodyCapabilities.canAddImportInMethodBody, canResolveImport = paradigm.methodBodyCapabilities.canResolveImportInMethod)) _ <- addTypeLookupForClasses(FinalizedDataTypeCase(tpeCase), finalizedTypeCaseClass(model, tpeCase)(canFindClass = ooParadigm.classCapabilities.canFindClassInClass, canAddImport = ooParadigm.classCapabilities.canAddImportInClass, canResolveImport = ooParadigm.classCapabilities.canResolveImportInClass)) _ <- addTypeLookupForConstructors(FinalizedDataTypeCase(tpeCase), finalizedTypeCaseClass(model, tpeCase)(canFindClass = ooParadigm.constructorCapabilities.canFindClassInConstructor, canAddImport = ooParadigm.constructorCapabilities.canAddImportInConstructor, canResolveImport = ooParadigm.constructorCapabilities.canResolveImportInConstructor)) } yield () } - _ <- addTypeLookupForMethods(dtpeRep, mostSpecificBaseInterfaceType(domain)(canFindClass=ooParadigm.methodBodyCapabilities.canFindClassInMethod, canAddImport =paradigm.methodBodyCapabilities.canAddImportInMethodBody, canResolveImport = paradigm.methodBodyCapabilities.canResolveImportInMethod)) - _ <- addTypeLookupForClasses(dtpeRep, mostSpecificBaseInterfaceType(domain)(canFindClass=ooParadigm.classCapabilities.canFindClassInClass, canAddImport = ooParadigm.classCapabilities.canAddImportInClass, canResolveImport = ooParadigm.classCapabilities.canResolveImportInClass)) - _ <- addTypeLookupForConstructors(dtpeRep, mostSpecificBaseInterfaceType(domain)(canFindClass=ooParadigm.constructorCapabilities.canFindClassInConstructor, canAddImport = ooParadigm.constructorCapabilities.canAddImportInConstructor, canResolveImport = ooParadigm.constructorCapabilities.canResolveImportInConstructor)) + _ <- addTypeLookupForMethods(dtpeRep, mostSpecificBaseInterfaceType(domain)(canFindClass = ooParadigm.methodBodyCapabilities.canFindClassInMethod, canAddImport = paradigm.methodBodyCapabilities.canAddImportInMethodBody, canResolveImport = paradigm.methodBodyCapabilities.canResolveImportInMethod)) + _ <- addTypeLookupForClasses(dtpeRep, mostSpecificBaseInterfaceType(domain)(canFindClass = ooParadigm.classCapabilities.canFindClassInClass, canAddImport = ooParadigm.classCapabilities.canAddImportInClass, canResolveImport = ooParadigm.classCapabilities.canResolveImportInClass)) + _ <- addTypeLookupForConstructors(dtpeRep, mostSpecificBaseInterfaceType(domain)(canFindClass = ooParadigm.constructorCapabilities.canFindClassInConstructor, canAddImport = ooParadigm.constructorCapabilities.canAddImportInConstructor, canResolveImport = ooParadigm.constructorCapabilities.canResolveImportInConstructor)) } yield () } @@ -607,16 +616,18 @@ trait TriviallyClean extends SharedOO { } object TriviallyClean { - type WithParadigm[P <: AnyParadigm] = TriviallyClean { val paradigm: P } + type WithParadigm[P <: AnyParadigm] = TriviallyClean {val paradigm: P} type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] - (base: P) - (nameProvider: NameProvider[base.syntax.Name], - oo: ObjectOriented.WithBase[base.type]) : TriviallyClean.WithParadigm[base.type] = - new TriviallyClean { - val paradigm: base.type = base - val names: NameProvider[paradigm.syntax.Name] = nameProvider - val ooParadigm: oo.type = oo - } + (base: P) + ( + nameProvider: NameProvider[base.syntax.Name], + oo: ObjectOriented.WithBase[base.type] + ): TriviallyClean.WithParadigm[base.type] = { + case class TC(override val paradigm: base.type)( + override val names: NameProvider[paradigm.syntax.Name], override val ooParadigm: oo.type + ) extends TriviallyClean + TC(base)(nameProvider, oo) + } } diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/Visitor.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/Visitor.scala similarity index 97% rename from core/src/main/scala/org/combinators/ep/approach/oo/Visitor.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/Visitor.scala index c52ec7fa..c7538966 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/Visitor.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/Visitor.scala @@ -1,15 +1,17 @@ package org.combinators.ep.approach.oo /*DI:LI:AD*/ +import org.combinators.cogen.paradigm.control.Imperative import org.combinators.ep.domain.GenericModel -import org.combinators.ep.domain.abstractions.{Attribute, DataType, DataTypeCase, Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.{AbstractSyntax, Command, EvolutionImplementationProvider, NameProvider} -import org.combinators.ep.generator.Command.Generator +import org.combinators.ep.domain.abstractions.{Attribute, DataType, DataTypeCase, Operation, Parameter} +import org.combinators.cogen.{AbstractSyntax, Command, NameProvider, TypeRep, InstanceRep} +import org.combinators.cogen.paradigm.{AnyParadigm, Generics, ObjectOriented, ParametricPolymorphism} +import org.combinators.ep.generator.EvolutionImplementationProvider import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.control.Imperative.WithBase -import org.combinators.ep.generator.paradigm.{AnyParadigm, Generics, ObjectOriented, ParametricPolymorphism} +import org.combinators.ep.domain.extensions._ +import org.combinators.ep.domain.abstractions._ +import AnyParadigm.syntax.forEach +import Imperative.WithBase +import Command.Generator /** * Straightforward implementation places all generated code in the current ep.* package. @@ -682,7 +684,7 @@ trait Visitor extends SharedOO with OperationAsClass { self => val makeClass: Generator[ClassContext, Unit] = { import ooParadigm.classCapabilities._ for { - parent <- toTargetLanguageType(TypeRep.DataType(parentType)) + parent <- toTargetLanguageType(DomainTpeRep.DataType(parentType)) _ <- resolveAndAddImport(parent) _ <- addParent(parent) _ <- forEach (tpeCase.attributes) { att => makeField(att) } @@ -794,7 +796,7 @@ object Visitor { val ooParadigm: oo.type = oo val visitorSpecifics: VisitorSpecifics = new VisitorSideEffect { - override val impParadigm: WithBase[paradigm.MethodBodyContext, paradigm.type] = imp + override val impParadigm: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type] = imp } } } diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/Visualize.scala b/approach/src/main/scala/org/combinators/ep/approach/oo/Visualize.scala similarity index 77% rename from core/src/main/scala/org/combinators/ep/approach/oo/Visualize.scala rename to approach/src/main/scala/org/combinators/ep/approach/oo/Visualize.scala index 67b10429..65e5e00e 100644 --- a/core/src/main/scala/org/combinators/ep/approach/oo/Visualize.scala +++ b/approach/src/main/scala/org/combinators/ep/approach/oo/Visualize.scala @@ -1,22 +1,29 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ +package org.combinators.ep.approach.oo +/*DI:LI:AD*/ + +import org.combinators.cogen.paradigm.{AnyParadigm, ObjectOriented} import org.combinators.ep.domain.{GenericModel, GraphViz} import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.generator.Command._ +import org.combinators.cogen.{NameProvider, Command, TypeRep, AbstractSyntax} +import org.combinators.cogen.Command._ import org.combinators.ep.generator._ import org.combinators.ep.generator.communication._ -import org.combinators.ep.generator.paradigm._ + +// Need EpCoGen extensions to CoGen +import org.combinators.ep.domain.extensions._ + /** - * Process model by generating representations suitable for GraphViz - * - * https://dreampuf.github.io/GraphvizOnline - * - * Choose "graphviz" as the approach and (for either Java or Scala) generate the resulting - * code. What it does, instead, is generate the OO solution and then creates files, either - * "eip.viz" (structural evolution) or "evolution.viz" (which also includes dependency links) - * that you can copy and paste into the above service. - */ + * Process model by generating representations suitable for GraphViz + * + * https://dreampuf.github.io/GraphvizOnline + * + * Choose "graphviz" as the approach and (for either Java or Scala) generate the resulting + * code. What it does, instead, is generate the OO solution and then creates files, either + * "eip.viz" (structural evolution) or "evolution.viz" (which also includes dependency links) + * that you can copy and paste into the above service. + */ trait Visualize extends SharedOO { val ooParadigm: ObjectOriented.WithBase[paradigm.type] @@ -78,50 +85,71 @@ trait Visualize extends SharedOO { (resultMap, m) => m.optimizations.foldLeft(resultMap) { (resultMap, pair) => resultMap.updated(pair._1, Set(pair._2) ++ resultMap.getOrElse(pair._1, Set.empty)) - }} + } + } val lastExp = latestModelDefiningInterface(domain) - val overriddenMap1 = domain.toSeq.filter(dm => lastExp.before(dm)).flatMap(m => m.optimizations).groupBy(_._1).map(f => (f._1, f._2.map(pair => pair._2).toSet)) //.groupBy{ case (tpe, op) => tpe. } + val overriddenMap1 = domain.toSeq.filter(dm => lastExp.before(dm)).flatMap(m => m.optimizations).groupBy(_._1).map(f => (f._1, f._2.map(pair => pair._2).toSet)) //.groupBy{ case (tpe, op) => tpe. } - println("OverrideMap: ", domain.name + "," + overriddenMap.map(pair => pair._1.name + " [" + pair._2.map(op => op.name) - .foldLeft("") {case (g,str) => g + str + ","} - + "], ") - .foldLeft("") { case (group, str) => group + str }) + println( + s"""OverrideMap: ${domain.name}, ${ + overriddenMap.map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + .foldLeft("") { case (g, str) => g + str + "," } + + "], ") + .foldLeft("") { case (group, str) => group + str } + }""") // Merging makes this more complicated BECAUSE there could be multiple Exp that are brought together, // and if so, then will need to BLEND together val pastWithExp = domain.former.filter(dm => dm == latestModelDefiningInterface(dm)) - val xyz = if (pastWithExp.length > 1) { pastWithExp.flatMap(m => dataTypeCasesWithNewOperations(m)) } else { Seq.empty } + val xyz = if (pastWithExp.length > 1) { + pastWithExp.flatMap(m => dataTypeCasesWithNewOperations(m)) + } else { + Seq.empty + } val mergeResults = xyz.groupBy(_._1).map(triple => triple._1 -> triple._2.flatMap(pm => pm._2)).filter(entry => entry._2.nonEmpty) // .map(pair => (pair._1, pair._2.flatMap(p => p._2).toSet)) if (domain.name.equals("oo3")) { - println ("SDS") + println("SDS") + } + val mergeResultsxxx = if (pastWithExp.length > 1) { + pastWithExp.flatMap(m => dataTypeCasesWithNewOperations(m)).toMap + } else { + Map.empty[DataTypeCase, Set[Operation]] } - val mergeResultsxxx = if (pastWithExp.length > 1) { pastWithExp.flatMap(m => dataTypeCasesWithNewOperations(m)).toMap } else { Map.empty[DataTypeCase, Set[Operation]] } val mergeMap = if (pastWithExp.length > 1) { - pastWithExp.foldLeft(overriddenMap){ (updatedMap, m) => + pastWithExp.foldLeft(overriddenMap) { (updatedMap, m) => dataTypeCasesWithNewOperations(m).foldLeft(updatedMap) { (nextMap, pair) => { nextMap.updated(pair._1, pair._2 ++ nextMap.getOrElse(pair._1, Set.empty)) - }} + } + } } // multiple Exp in former, so we have to join together - } else { overriddenMap} + } else { + overriddenMap + } val mergeMap0 = if (pastWithExp.length > 1) { - pastWithExp.foldLeft(Map.empty[DataTypeCase, Set[Operation]]){ (updatedMap, m) => + pastWithExp.foldLeft(Map.empty[DataTypeCase, Set[Operation]]) { (updatedMap, m) => dataTypeCasesWithNewOperations(m).foldLeft(updatedMap) { (nextMap, pair) => { nextMap.updated(pair._1, pair._2 ++ nextMap.getOrElse(pair._1, Set.empty)) - }} + } + } } // multiple Exp in former, so we have to join together - } else { Map.empty[DataTypeCase, Set[Operation]]} + } else { + Map.empty[DataTypeCase, Set[Operation]] + } - println("MergeMap: ", domain.name + "," + mergeMap0.map(pair => pair._1.name + " [" + pair._2.map(op => op.name) - .foldLeft("") {case (g,str) => g + str + ","} - + "], ") - .foldLeft("") { case (group, str) => group + str }) + println( + s"""MergeMap: ${domain.name}, ${ + mergeMap0.map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + .foldLeft("") { case (g, str) => g + str + "," } + + "], ") + .foldLeft("") { case (group, str) => group + str } + }""") // whenever a new Exp is defined, MUST duplicate logic for all producer methods; incorporate into logic below val addedExp = domain == latestModelDefiningInterface(domain) @@ -140,7 +168,7 @@ trait Visualize extends SharedOO { val affected = allOperations.map(op => { - val dts = allDataTypeCases.filter(tpe => { + val dts = allDataTypeCases.filter(tpe => { val mt = domain.findTypeCase(tpe).get val mo = domain.findOperation(op).get @@ -181,15 +209,18 @@ trait Visualize extends SharedOO { } } } - println("ResultsMap: ", domain.name + "," + results0.map(pair => pair._1.name + " [" + pair._2.map(op => op.name) - .foldLeft("") {case (g,str) => g + str + ","} - + "], ") - .foldLeft("") { case (group, str) => group + str }) + println( + s"""ResultsMap: ${domain.name}, ${ + results0.map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + .foldLeft("") { case (g, str) => g + str + "," } + + "], ") + .foldLeft("") { case (group, str) => group + str } + }""") val res = Seq(overriddenMap1, mergeResults, resultss) - .flatten // List[(String, String)] - .groupBy { case (k, _) => k } // Map[String, List[(String, String)]] + .flatten // List[(String, String)] + .groupBy { case (k, _) => k } // Map[String, List[(String, String)]] .map(pair => (pair._1, pair._2.flatMap(p => p._2).toSet)) //.mapValues(_.map { case (_, v) => v }) if (!res.equals(results)) { @@ -215,7 +246,9 @@ trait Visualize extends SharedOO { pastWithExp.flatMap(m => dataTypeCasesWithNewOperations(m)).groupBy(_._1) .map(triple => triple._1 -> triple._2.flatMap(pm => pm._2)) .filter(entry => entry._2.nonEmpty) - } else { Seq.empty } + } else { + Seq.empty + } //val merged1 = xyz.groupBy(_._1).map(triple => triple._1 -> triple._2.flatMap(pm => pm._2)).filter(entry => entry._2.nonEmpty) // whenever a new Exp is defined, MUST duplicate logic for all producer methods; incorporate into logic below @@ -234,9 +267,9 @@ trait Visualize extends SharedOO { }).filter(pair => pair._2.nonEmpty).toMap Seq(overridden, merged, updated) - .flatten - .groupBy { case (k, _) => k } - .map(pair => (pair._1, pair._2.flatMap(p => p._2).toSet)) + .flatten + .groupBy { case (k, _) => k } + .map(pair => (pair._1, pair._2.flatMap(p => p._2).toSet)) } def latestModelDefiningNewTypeInterface(domain: GenericModel): GenericModel = { @@ -255,8 +288,8 @@ trait Visualize extends SharedOO { } /** - * Every stage needs a Factory - */ + * Every stage needs a Factory + */ def latestModelDefiningNewFactoryType(domain: GenericModel): GenericModel = { if (domain.optimizations.nonEmpty || domain.isDomainBase || domain.typeCases.nonEmpty || domain == latestModelDefiningNewTypeInterface(domain)) { domain @@ -399,7 +432,7 @@ trait Visualize extends SharedOO { domain } else { // is there a single type that can represent the "least upper bound" of all prior branches. - val ancestorsWithTypeInterfaces = ancestorsDefiningNewTypeInterfaces2(domain) // INTERPRETER + val ancestorsWithTypeInterfaces = ancestorsDefiningNewTypeInterfaces2(domain) // INTERPRETER //val ancestorsWithTypeInterfaces = domain.former.map(ancestor => latestModelDefiningNewTypeInterface(ancestor)).distinct // COCO if (ancestorsWithTypeInterfaces.size == 1 && !ancestorsWithTypeInterfaces.head.isDomainBase) { // take care to avoid falling below "floor" @@ -431,87 +464,87 @@ trait Visualize extends SharedOO { //gdomain.toSeq.foreach(m => println(m.name, latestModelDefiningInterface(m).name)) //gdomain.toSeq.foreach(m => println(m.name, dataTypeCasesWithNewOperations(m).map(pair => pair._1.name ++ "," ++ pair._2.map(op => op.name)))) -// gdomain.toSeq.reverse.foreach(m => println(m.name, -// dataTypeCasesWithNewOperations(m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) -// .foldLeft("") {case (g,str) => g + str + ","} -// + "], ") -// .foldLeft("") { case (group, str) => group + str } -// )) - gdomain.toSeq.foreach(m => println(m.name, " has ", latestModelDefiningNewTypeInterface2(m).name)) + // gdomain.toSeq.reverse.foreach(m => println(m.name, + // dataTypeCasesWithNewOperations(m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + // .foldLeft("") {case (g,str) => g + str + ","} + // + "], ") + // .foldLeft("") { case (group, str) => group + str } + // )) + gdomain.toSeq.foreach(m => println(s"""${m.name} has ${latestModelDefiningNewTypeInterface2(m).name}""")) println() gdomain.toSeq.foreach(m => - println(m.name, " has ", latestModelDefiningNewTypeInterface3(m).name)) + println(s"""${m.name} has, ${latestModelDefiningNewTypeInterface3(m).name}""")) print("CoCo:" + gdomain.name) val outputCoCO = new java.io.File(new java.io.File("target"), "coco-newDataTypeCases.txt") - val fileWriterCoCo = new java.io.FileWriter (outputCoCO, true) + val fileWriterCoCo = new java.io.FileWriter(outputCoCO, true) gdomain.toSeq.distinct.foreach(m => { fileWriterCoCo.write(m.name + "," + - cocoNewDataTypeCasesWithNewOperations(m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) - .foldLeft("") { case (g, str) => g + str + "," } - + "], ") - .foldLeft("") { case (group, str) => group + str } + "\n") + cocoNewDataTypeCasesWithNewOperations(m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + .foldLeft("") { case (g, str) => g + str + "," } + + "], ") + .foldLeft("") { case (group, str) => group + str } + "\n") } ) fileWriterCoCo.close() print("ObjectAlgebras:" + gdomain.name) val outputObjectAlgebras = new java.io.File(new java.io.File("target"), "algebra-newDataTypeCases.txt") - val fileWriterObjAlg = new java.io.FileWriter (outputObjectAlgebras, true) + val fileWriterObjAlg = new java.io.FileWriter(outputObjectAlgebras, true) gdomain.toSeq.distinct.foreach(m => { fileWriterObjAlg.write(m.name + "," + - objectAlgebrasDataTypeCasesWithNewOperations(domainSpecific, m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) - .foldLeft("") { case (g, str) => g + str + "," } - + "], ") - .foldLeft("") { case (group, str) => group + str } + "\n") + objectAlgebrasDataTypeCasesWithNewOperations(domainSpecific, m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + .foldLeft("") { case (g, str) => g + str + "," } + + "], ") + .foldLeft("") { case (group, str) => group + str } + "\n") } ) fileWriterObjAlg.close() print("Trivially:" + gdomain.name) - val outputObjectTrivially= new java.io.File(new java.io.File("target"), "trivially-newDataTypeCases.txt") - val fileWriterTrivially= new java.io.FileWriter (outputObjectTrivially, true) + val outputObjectTrivially = new java.io.File(new java.io.File("target"), "trivially-newDataTypeCases.txt") + val fileWriterTrivially = new java.io.FileWriter(outputObjectTrivially, true) gdomain.toSeq.distinct.foreach(m => { fileWriterTrivially.write(m.name + "," + - triviallyDataTypeCasesWithNewOperations(m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) - .foldLeft("") { case (g, str) => g + str + "," } - + "], ") - .foldLeft("") { case (group, str) => group + str } + "\n") + triviallyDataTypeCasesWithNewOperations(m).map(pair => pair._1.name + " [" + pair._2.map(op => op.name) + .foldLeft("") { case (g, str) => g + str + "," } + + "], ") + .foldLeft("") { case (group, str) => group + str } + "\n") } ) fileWriterTrivially.close() -// -// // document evolutions -// //GraphViz.outputGraphViz(gdomain) -// -// // Document EIPs -// //GraphViz.outputGraphWithDependenciesViz(gdomain, domainSpecific) -// -// // produce table -// val flat = gdomain.flatten -// -// // header -// print("OP,") -// flat.typeCases.foreach(tpe => { -// print(tpe.name + ",") -// }) -// println() -// -// flat.ops.foreach(op => { -// print(op.name + ",") -// flat.typeCases.foreach(tpe => { -// val opt = latestModelDefiningOperatorClass(gdomain, tpe, op, domainSpecific) -// -// if (opt.isEmpty) { -// print("-,") -// } else { -// print(opt.get.name + ",") -// } -// }) -// println() -// }) + // + // // document evolutions + // //GraphViz.outputGraphViz(gdomain) + // + // // Document EIPs + // //GraphViz.outputGraphWithDependenciesViz(gdomain, domainSpecific) + // + // // produce table + // val flat = gdomain.flatten + // + // // header + // print("OP,") + // flat.typeCases.foreach(tpe => { + // print(tpe.name + ",") + // }) + // println() + // + // flat.ops.foreach(op => { + // print(op.name + ",") + // flat.typeCases.foreach(tpe => { + // val opt = latestModelDefiningOperatorClass(gdomain, tpe, op, domainSpecific) + // + // if (opt.isEmpty) { + // print("-,") + // } else { + // print(opt.get.name + ",") + // } + // }) + // println() + // }) val flatDomain = gdomain.linearize.flatten for { @@ -522,17 +555,21 @@ trait Visualize extends SharedOO { } object Visualize { - type WithParadigm[P <: AnyParadigm] = Visualize { val paradigm: P } + type WithParadigm[P <: AnyParadigm] = Visualize {val paradigm: P} type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] - (base: P) - (nameProvider: NameProvider[base.syntax.Name], - oo: ObjectOriented.WithBase[base.type] - ): Visualize.WithParadigm[base.type] = - new Visualize { - override val paradigm: base.type = base - override val names: NameProvider[paradigm.syntax.Name] = nameProvider - override val ooParadigm: ObjectOriented.WithBase[paradigm.type] = oo - } + (base: P) + ( + nameProvider: NameProvider[base.syntax.Name], + oo: ObjectOriented.WithBase[base.type] + ): Visualize.WithParadigm[base.type] = { + case class V( + override val paradigm: base.type + )( + override val names: NameProvider[paradigm.syntax.Name], + override val ooParadigm: ObjectOriented.WithBase[paradigm.type] + ) extends Visualize + V(base)(nameProvider, oo) + } } diff --git a/attic/AlgTest/AlgTest.java b/attic/AlgTest/AlgTest.java new file mode 100644 index 00000000..58d95bb8 --- /dev/null +++ b/attic/AlgTest/AlgTest.java @@ -0,0 +1,90 @@ +class AlgTest { + interface Algebra { + public R lit(double value); + public R add(R left, R right); + public R sub(R left, R right); + } + + interface AlgebraExt extends Algebra { + public R mult(R left, R right); + } + + interface Combined extends MultBy, Eval {} + interface CombinedExt extends Combined, PrettyP {} + + + interface MultBy { + public Combined multBy(Combined other); + } + interface MultByExt { + public CombinedExt multBy(CombinedExt other); + } + + interface MultByAlg extends Algebra { + public default MultBy lit(double value) { + return (AlgebraProducer other) -> { + return (Algebra alg) -> { + Double counter = Math.floor(Math.abs(value)); + R result = other.get(alg); + while (1.0 < counter) { + result = alg.add(result, other.get(alg)); + counter = counter - 1.0; + } + if (this.getValue() < 0.0) { + result = alg.sub(alg.lit(0.0), result); + } + return result; + }; + }; + } + public default MultBy add(MultBy left, MultBy right) { + return (AlgebraProducer other) -> { + return (Algebra alg) -> { + return alg.add(left.multBy(other).get(alg), right.multBy(other).get(alg)); + }; + }; + } + public default MultBy sub(MultBy left, MultBy right) { + return (AlgebraProducer other) -> { + return (Algebra alg) -> { + return alg.sub(left.multBy(other).get(alg), right.multBy(other).get(alg)); + }; + }; + } + } + + interface Eval { + public Double eval(); + } + + interface EvalAlg extends Algebra { + public default Eval lit(double value) { + return () -> { return value; }; + } + public default Eval add(Eval left, Eval right) { + return () -> { return left.eval() + right.eval(); }; + } + public default Eval sub(Eval left, Eval right) { + return () -> { return left.eval() - right.eval(); }; + } + } + + interface AlgebraProducerAlg extends Algebra { + public default AlgebraProducer lit(double value) { + return (Algebra alg) -> { return alg.lit(value); }; + } + public default AlgebraProducer add(AlgebraProducer left, AlgebraProducer right) { + return (Algebra alg) -> { return alg.add(left.get(alg), right.get(alg)); }; + } + public default AlgebraProducer sub(AlgebraProducer left, AlgebraProducer right) { + return (Algebra alg) -> { return alg.sub(left.get(alg), right.get(alg)); }; + } + } + + public static void main(String[] args) { + MultByAlg multBy = new MultByAlg(); + EvalAlg evalAlg = new EvalAlg(); + AlgebraProducerAlg prodAlg = new AlgebraProducerAlg(); + System.out.println(multBy.lit(5).multBy(prodAlg.add(prodAlg.lit(1), prodAlg.lit(2)))); + } +} diff --git a/attic/AlgTest/AlgTest_CombinedProblem.java b/attic/AlgTest/AlgTest_CombinedProblem.java new file mode 100644 index 00000000..58d95bb8 --- /dev/null +++ b/attic/AlgTest/AlgTest_CombinedProblem.java @@ -0,0 +1,90 @@ +class AlgTest { + interface Algebra { + public R lit(double value); + public R add(R left, R right); + public R sub(R left, R right); + } + + interface AlgebraExt extends Algebra { + public R mult(R left, R right); + } + + interface Combined extends MultBy, Eval {} + interface CombinedExt extends Combined, PrettyP {} + + + interface MultBy { + public Combined multBy(Combined other); + } + interface MultByExt { + public CombinedExt multBy(CombinedExt other); + } + + interface MultByAlg extends Algebra { + public default MultBy lit(double value) { + return (AlgebraProducer other) -> { + return (Algebra alg) -> { + Double counter = Math.floor(Math.abs(value)); + R result = other.get(alg); + while (1.0 < counter) { + result = alg.add(result, other.get(alg)); + counter = counter - 1.0; + } + if (this.getValue() < 0.0) { + result = alg.sub(alg.lit(0.0), result); + } + return result; + }; + }; + } + public default MultBy add(MultBy left, MultBy right) { + return (AlgebraProducer other) -> { + return (Algebra alg) -> { + return alg.add(left.multBy(other).get(alg), right.multBy(other).get(alg)); + }; + }; + } + public default MultBy sub(MultBy left, MultBy right) { + return (AlgebraProducer other) -> { + return (Algebra alg) -> { + return alg.sub(left.multBy(other).get(alg), right.multBy(other).get(alg)); + }; + }; + } + } + + interface Eval { + public Double eval(); + } + + interface EvalAlg extends Algebra { + public default Eval lit(double value) { + return () -> { return value; }; + } + public default Eval add(Eval left, Eval right) { + return () -> { return left.eval() + right.eval(); }; + } + public default Eval sub(Eval left, Eval right) { + return () -> { return left.eval() - right.eval(); }; + } + } + + interface AlgebraProducerAlg extends Algebra { + public default AlgebraProducer lit(double value) { + return (Algebra alg) -> { return alg.lit(value); }; + } + public default AlgebraProducer add(AlgebraProducer left, AlgebraProducer right) { + return (Algebra alg) -> { return alg.add(left.get(alg), right.get(alg)); }; + } + public default AlgebraProducer sub(AlgebraProducer left, AlgebraProducer right) { + return (Algebra alg) -> { return alg.sub(left.get(alg), right.get(alg)); }; + } + } + + public static void main(String[] args) { + MultByAlg multBy = new MultByAlg(); + EvalAlg evalAlg = new EvalAlg(); + AlgebraProducerAlg prodAlg = new AlgebraProducerAlg(); + System.out.println(multBy.lit(5).multBy(prodAlg.add(prodAlg.lit(1), prodAlg.lit(2)))); + } +} diff --git a/jgitserv/src/main/resources/logback.xml b/attic/jgitserv/src/main/resources/logback.xml similarity index 100% rename from jgitserv/src/main/resources/logback.xml rename to attic/jgitserv/src/main/resources/logback.xml diff --git a/jgitserv/src/main/scala/org/combinators/jgitserv/BranchTransaction.scala b/attic/jgitserv/src/main/scala/org/combinators/jgitserv/BranchTransaction.scala similarity index 100% rename from jgitserv/src/main/scala/org/combinators/jgitserv/BranchTransaction.scala rename to attic/jgitserv/src/main/scala/org/combinators/jgitserv/BranchTransaction.scala diff --git a/jgitserv/src/main/scala/org/combinators/jgitserv/GitService.scala b/attic/jgitserv/src/main/scala/org/combinators/jgitserv/GitService.scala similarity index 100% rename from jgitserv/src/main/scala/org/combinators/jgitserv/GitService.scala rename to attic/jgitserv/src/main/scala/org/combinators/jgitserv/GitService.scala diff --git a/jgitserv/src/main/scala/org/combinators/jgitserv/ResourcePersistable.scala b/attic/jgitserv/src/main/scala/org/combinators/jgitserv/ResourcePersistable.scala similarity index 100% rename from jgitserv/src/main/scala/org/combinators/jgitserv/ResourcePersistable.scala rename to attic/jgitserv/src/main/scala/org/combinators/jgitserv/ResourcePersistable.scala diff --git a/jgitserv/src/main/scala/org/combinators/jgitserv/Test.scala b/attic/jgitserv/src/main/scala/org/combinators/jgitserv/Test.scala similarity index 100% rename from jgitserv/src/main/scala/org/combinators/jgitserv/Test.scala rename to attic/jgitserv/src/main/scala/org/combinators/jgitserv/Test.scala diff --git a/language/cpp/src/main/resources/application.conf b/attic/language/cpp/src/main/resources/application.conf similarity index 100% rename from language/cpp/src/main/resources/application.conf rename to attic/language/cpp/src/main/resources/application.conf diff --git a/language/cpp/src/main/resources/cpp-resources/Makefile b/attic/language/cpp/src/main/resources/cpp-resources/Makefile similarity index 100% rename from language/cpp/src/main/resources/cpp-resources/Makefile rename to attic/language/cpp/src/main/resources/cpp-resources/Makefile diff --git a/language/cpp/src/main/resources/logback.xml b/attic/language/cpp/src/main/resources/logback.xml similarity index 100% rename from language/cpp/src/main/resources/logback.xml rename to attic/language/cpp/src/main/resources/logback.xml diff --git a/language/cpp/src/main/resources/routes b/attic/language/cpp/src/main/resources/routes similarity index 100% rename from language/cpp/src/main/resources/routes rename to attic/language/cpp/src/main/resources/routes diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPP.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPP.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPP.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPP.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPBinaryMethod.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPBinaryMethod.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPBinaryMethod.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPBinaryMethod.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPUnitTestGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPUnitTestGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPUnitTestGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/CPPUnitTestGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/DataTypeSubclassGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/DataTypeSubclassGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/DataTypeSubclassGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/DataTypeSubclassGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/PerformanceTestGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/PerformanceTestGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/PerformanceTestGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/PerformanceTestGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/README.txt b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/README.txt similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/README.txt rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/README.txt diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/TestGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/TestGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/TestGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/TestGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e0.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e0.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e0.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e0.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e1.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e1.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e1.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e1.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e2.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e2.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e2.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e2.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e3.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e3.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e3.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e3.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e4.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e4.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e4.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e4.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e5.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e5.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e5.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e5.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e6.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e6.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e6.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/cpp_e6.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/oo/build.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/oo/build.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/oo/build.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/oo/build.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitor/build.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitor/build.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitor/build.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitor/build.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitorTable/build.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitorTable/build.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitorTable/build.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/deployment/visitorTable/build.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/CPPOOTestGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/CPPOOTestGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/CPPOOTestGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/CPPOOTestGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/Evolution_Scala.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/Evolution_Scala.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/Evolution_Scala.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/Evolution_Scala.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/StraightGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/StraightGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/StraightGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/oo/StraightGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorTestGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorTestGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorTestGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/CPPVisitorTestGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/EvolutionVisitor.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/EvolutionVisitor.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/EvolutionVisitor.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitor/EvolutionVisitor.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPTableTestGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPTableTestGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPTableTestGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPTableTestGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPVisitorTableGenerator.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPVisitorTableGenerator.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPVisitorTableGenerator.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/CPPVisitorTableGenerator.scala diff --git a/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/EvolutionVisitor.scala b/attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/EvolutionVisitor.scala similarity index 100% rename from language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/EvolutionVisitor.scala rename to attic/language/cpp/src/main/scala/org/combinators/ep/language/cpp/visitorTable/EvolutionVisitor.scala diff --git a/language/gj/src/main/resources/application.conf b/attic/language/gj/src/main/resources/application.conf similarity index 100% rename from language/gj/src/main/resources/application.conf rename to attic/language/gj/src/main/resources/application.conf diff --git a/language/gj/src/main/resources/logback.xml b/attic/language/gj/src/main/resources/logback.xml similarity index 100% rename from language/gj/src/main/resources/logback.xml rename to attic/language/gj/src/main/resources/logback.xml diff --git a/language/gj/src/main/resources/routes b/attic/language/gj/src/main/resources/routes similarity index 100% rename from language/gj/src/main/resources/routes rename to attic/language/gj/src/main/resources/routes diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/GJ.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/GJ.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/GJ.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/GJ.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/GJGenerator.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/GJGenerator.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/GJGenerator.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/GJGenerator.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/GJlWithPath.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/GJlWithPath.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/GJlWithPath.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/GJlWithPath.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/PerformanceTestGenerator.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/PerformanceTestGenerator.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/PerformanceTestGenerator.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/PerformanceTestGenerator.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/TestGenerator.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/TestGenerator.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/TestGenerator.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/TestGenerator.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/UnitTestGenerator.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/UnitTestGenerator.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/UnitTestGenerator.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/UnitTestGenerator.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/WadlerGenerator.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/WadlerGenerator.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/WadlerGenerator.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/WadlerGenerator.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/deployment/wadler/build.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/deployment/wadler/build.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/deployment/wadler/build.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/deployment/wadler/build.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/e0.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/e0.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/e0.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/e0.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/e1.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/e1.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/e1.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/e1.scala diff --git a/language/gj/src/main/scala/org/combinators/ep/language/gj/wadler/Evolution.scala b/attic/language/gj/src/main/scala/org/combinators/ep/language/gj/wadler/Evolution.scala similarity index 100% rename from language/gj/src/main/scala/org/combinators/ep/language/gj/wadler/Evolution.scala rename to attic/language/gj/src/main/scala/org/combinators/ep/language/gj/wadler/Evolution.scala diff --git a/language/haskell/src/main/resources/application.conf b/attic/language/haskell/src/main/resources/application.conf similarity index 100% rename from language/haskell/src/main/resources/application.conf rename to attic/language/haskell/src/main/resources/application.conf diff --git a/language/haskell/src/main/resources/haskell-code/Benchmark/Benchmark.hs b/attic/language/haskell/src/main/resources/haskell-code/Benchmark/Benchmark.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Benchmark/Benchmark.hs rename to attic/language/haskell/src/main/resources/haskell-code/Benchmark/Benchmark.hs diff --git a/language/haskell/src/main/resources/haskell-code/Data/CallStack.hs b/attic/language/haskell/src/main/resources/haskell-code/Data/CallStack.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Data/CallStack.hs rename to attic/language/haskell/src/main/resources/haskell-code/Data/CallStack.hs diff --git a/language/haskell/src/main/resources/haskell-code/Data/SrcLoc.hs b/attic/language/haskell/src/main/resources/haskell-code/Data/SrcLoc.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Data/SrcLoc.hs rename to attic/language/haskell/src/main/resources/haskell-code/Data/SrcLoc.hs diff --git a/language/haskell/src/main/resources/haskell-code/Test/HUnit.hs b/attic/language/haskell/src/main/resources/haskell-code/Test/HUnit.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Test/HUnit.hs rename to attic/language/haskell/src/main/resources/haskell-code/Test/HUnit.hs diff --git a/language/haskell/src/main/resources/haskell-code/Test/HUnit/Base.hs b/attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Base.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Test/HUnit/Base.hs rename to attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Base.hs diff --git a/language/haskell/src/main/resources/haskell-code/Test/HUnit/Lang.hs b/attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Lang.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Test/HUnit/Lang.hs rename to attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Lang.hs diff --git a/language/haskell/src/main/resources/haskell-code/Test/HUnit/Terminal.hs b/attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Terminal.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Test/HUnit/Terminal.hs rename to attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Terminal.hs diff --git a/language/haskell/src/main/resources/haskell-code/Test/HUnit/Text.hs b/attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Text.hs similarity index 100% rename from language/haskell/src/main/resources/haskell-code/Test/HUnit/Text.hs rename to attic/language/haskell/src/main/resources/haskell-code/Test/HUnit/Text.hs diff --git a/language/haskell/src/main/resources/logback.xml b/attic/language/haskell/src/main/resources/logback.xml similarity index 100% rename from language/haskell/src/main/resources/logback.xml rename to attic/language/haskell/src/main/resources/logback.xml diff --git a/language/haskell/src/main/resources/routes b/attic/language/haskell/src/main/resources/routes similarity index 100% rename from language/haskell/src/main/resources/routes rename to attic/language/haskell/src/main/resources/routes diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HUnitTestGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HUnitTestGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/HUnitTestGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HUnitTestGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/Haskell.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/Haskell.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/Haskell.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/Haskell.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellBinaryMethod.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellBinaryMethod.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellBinaryMethod.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellBinaryMethod.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellWithPath.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellWithPath.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellWithPath.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/HaskellWithPath.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/PerformanceTestGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/PerformanceTestGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/PerformanceTestGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/PerformanceTestGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/README.txt b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/README.txt similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/README.txt rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/README.txt diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/StandardHaskellBinaryMethod.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/StandardHaskellBinaryMethod.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/StandardHaskellBinaryMethod.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/StandardHaskellBinaryMethod.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/TestGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/TestGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/TestGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/TestGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteProducer.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteProducer.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteProducer.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteProducer.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteTestGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteTestGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteTestGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ALaCarteTestGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ERROR.txt b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ERROR.txt similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ERROR.txt rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/ERROR.txt diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/Evolution.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/Evolution.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/Evolution.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/alacarte/Evolution.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/alacarte/build.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/alacarte/build.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/alacarte/build.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/alacarte/build.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/grow/build.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/grow/build.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/grow/build.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/grow/build.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/straight/build.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/straight/build.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/straight/build.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/deployment/straight/build.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e0.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e0.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e0.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e0.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e1.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e1.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e1.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e1.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e2.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e2.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e2.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e2.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e3.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e3.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e3.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e3.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e4.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e4.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e4.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e4.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e5.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e5.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e5.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e5.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e6.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e6.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/e6.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/e6.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/ERROR.txt b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/ERROR.txt similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/ERROR.txt rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/ERROR.txt diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/Evolution.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/Evolution.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/Evolution.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/Evolution.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowTestGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowTestGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowTestGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/grow/GrowTestGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/performance/StressTest.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/performance/StressTest.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/performance/StressTest.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/performance/StressTest.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/EvolutionStraight.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/EvolutionStraight.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/EvolutionStraight.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/EvolutionStraight.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightTestGenerator.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightTestGenerator.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightTestGenerator.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/StraightTestGenerator.scala diff --git a/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/package.scala b/attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/package.scala similarity index 100% rename from language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/package.scala rename to attic/language/haskell/src/main/scala/org/combinators/ep/language/haskell/straight/package.scala diff --git a/language/scala/src/main/resources/org/combinators/ep/language/scala/gitignore b/attic/language/scala/src/main/resources/org/combinators/ep/language/scala/gitignore similarity index 100% rename from language/scala/src/main/resources/org/combinators/ep/language/scala/gitignore rename to attic/language/scala/src/main/resources/org/combinators/ep/language/scala/gitignore diff --git a/language/scala/src/main/resources/scala-code/tree/Tree.scala b/attic/language/scala/src/main/resources/scala-code/tree/Tree.scala similarity index 100% rename from language/scala/src/main/resources/scala-code/tree/Tree.scala rename to attic/language/scala/src/main/resources/scala-code/tree/Tree.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/CodeGenerator.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/CodeGenerator.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/CodeGenerator.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/CodeGenerator.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/ContextSpecificResolver.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/ContextSpecificResolver.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/ContextSpecificResolver.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/ContextSpecificResolver.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/Main.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/Main.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/Main.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/Main.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/OperatorExprs.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/OperatorExprs.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/OperatorExprs.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/OperatorExprs.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/ShapeMain.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/ShapeMain.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/ShapeMain.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/ShapeMain.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/Syntax.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/Syntax.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/Syntax.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/Syntax.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/config.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/config.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/config.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/config.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/contexts.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/contexts.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/contexts.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/contexts.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/AnyParadigm.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/AnyParadigm.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/AnyParadigm.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/AnyParadigm.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/BlockContextManipulator.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/BlockContextManipulator.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/BlockContextManipulator.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/BlockContextManipulator.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/Functional.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/Functional.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/Functional.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/Functional.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ObjectOriented.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ObjectOriented.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ObjectOriented.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ObjectOriented.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/control/Functional.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/control/Functional.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/control/Functional.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/control/Functional.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Arithmetic.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Arithmetic.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Arithmetic.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Arithmetic.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Assertions.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Assertions.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Assertions.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Assertions.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Booleans.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Booleans.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Booleans.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Booleans.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Equality.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Equality.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Equality.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Equality.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Lists.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Lists.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Lists.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Lists.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/RealArithmetic.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/RealArithmetic.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/RealArithmetic.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/RealArithmetic.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Strings.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Strings.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Strings.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Strings.scala diff --git a/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Trees.scala b/attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Trees.scala similarity index 100% rename from language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Trees.scala rename to attic/language/scala/src/main/scala/org/combinators/ep/language/scala/paradigm/ffi/Trees.scala diff --git a/attic/scala_trees/.bsp/sbt.json b/attic/scala_trees/.bsp/sbt.json new file mode 100644 index 00000000..54649f1c --- /dev/null +++ b/attic/scala_trees/.bsp/sbt.json @@ -0,0 +1 @@ +{"name":"sbt","version":"1.9.0","bspVersion":"2.1.0-M1","languages":["scala"],"argv":["/usr/lib64/openjdk-17/bin/java","-Xms100m","-Xmx100m","-classpath","/home/fenix/.local/share/JetBrains/IdeaIC2025.1/Scala/launcher/sbt-launch.jar","-Dsbt.script=/home/fenix/.sdkman/candidates/sbt/current/bin/sbt","xsbt.boot.Boot","-bsp"]} \ No newline at end of file diff --git a/attic/scala_trees/build.sbt b/attic/scala_trees/build.sbt new file mode 100644 index 00000000..aaad102d --- /dev/null +++ b/attic/scala_trees/build.sbt @@ -0,0 +1 @@ +scalaVersion := "3.6.4" diff --git a/attic/scala_trees/project/build.properties b/attic/scala_trees/project/build.properties new file mode 100644 index 00000000..40b3b8e7 --- /dev/null +++ b/attic/scala_trees/project/build.properties @@ -0,0 +1 @@ +sbt.version=1.9.0 diff --git a/attic/scala_trees/src/main/scala/m0/M0.scala b/attic/scala_trees/src/main/scala/m0/M0.scala new file mode 100644 index 00000000..71068b3a --- /dev/null +++ b/attic/scala_trees/src/main/scala/m0/M0.scala @@ -0,0 +1,32 @@ +package m0 + +trait M0ExtFam[F]: + type M0ExtT + +trait ExpM0[F]: + given M0E + +enum ExpM0[F]: + case Lit[F](value: Double) extends ExpM0[F] + case Add[F](left: ExpM0[F], right: ExpM0[F]) extends ExpM0[F] + case M0Ext[F](e: M0ExtFam[F])(val ext: e.M0ExtT) extends ExpM0[F] + + +trait M0 + +given m0m0Ext: M0ExtFam[M0]: + type M0ExtT = Void + +def evalExp_M0[F](helpWith: (e: M0ExtFam[F]) => e.M0ExtT => Double)(exp: ExpM0[F]): Double = + exp match { + case ExpM0.Lit(d) => d + case ExpM0.Add(left, right) => + val help = evalExp_M0(helpWith) + help(left) + help(right) + case ext@ExpM0.M0Ext(_) => + helpWith(ext.e)(ext.ext) + } + +def evalExpM0(exp: ExpM0[M0]): Double = + evalExp_M0(helpWithEvalM0)(exp) +def helpWithEvalM0(e: M0ExtFam[M0])(exp: e.M0ExtT): Double = ??? diff --git a/attic/scala_trees/src/main/scala/m1/M1.scala b/attic/scala_trees/src/main/scala/m1/M1.scala new file mode 100644 index 00000000..b1ef725e --- /dev/null +++ b/attic/scala_trees/src/main/scala/m1/M1.scala @@ -0,0 +1,32 @@ +package m1 + +import m0.{ExpM0, M0ExtFam, evalExp_M0} + +trait M1ExtFam[F]: + type M1ExtT + given M0ExtFam[F] = compiletime.deferred + +enum ExpM1[F]: + case Sub[F](left: ExpM0[F], right: ExpM0[F]) extends ExpM1[F] + case M1Ext[F](m1ext: M1ExtFam[F])(ext: m1ext.M1ExtT) extends ExpM1[F] + +trait M1 + +given m0m1Ext: M0ExtFam[M1]: + type M0ExtT = ExpM1[M1] + +given m1m1Ext: M1ExtFam[M1]: + type M1ExtT = Void + +def evalExp_M1[F](helpWith: (e1: M1ExtFam[F]) => e1.M1ExtT => Double)(exp: ExpM1[F]): Double = + exp match { + case ExpM1.Sub(left, right) => + val help = evalExp_M0[F](e0 => evalExp_M1(helpWith)) + help(left) - help(right) + case ext@ExpM0.M0Ext(_) => + helpWith(ext.e)(ext.ext) + } + +//def evalExpM1(exp: ExpM0[M0]): Double = +// evalExp_M0(helpWithEvalM0)(exp) +//def helpWithEvalM0(e: M0ExtFam[M0])(exp: e.M0ExtT): Double = ??? \ No newline at end of file diff --git a/build.sbt b/build.sbt index abf39d28..9c250035 100644 --- a/build.sbt +++ b/build.sbt @@ -1,46 +1,67 @@ +import sbt.Keys._ +import sbt.Resolver +import xerial.sbt.Sonatype.sonatypeCentralHost + /** Settings shared globally. **/ lazy val commonSettings = Seq( - version := "1.0.0-SNAPSHOT", organization := "org.combinators", - scalaVersion := "2.12.17", - - resolvers ++= Seq( - Resolver.sonatypeRepo("releases"), - Resolver.typesafeRepo("releases") - ), + scalaVersion := "3.7.4", + + resolvers += Resolver.typesafeRepo("releases"), + resolvers ++= Resolver.sonatypeOssRepos("releases"), Compile/scalacOptions ++= Seq( + "-explain", "-unchecked", "-deprecation", "-feature", "-language:implicitConversions", - "-Ypartial-unification", - "-language:higherKinds" - ), - - Compile/scalacOptions ++= Seq( - "-unchecked", - "-deprecation", - "-feature", - "-language:implicitConversions" + "-language:higherKinds", + "-Xkind-projector:underscores", ), libraryDependencies ++= Seq( - "org.combinators" %% "jgitserv" % "0.0.1", - "org.scalactic" %% "scalactic" % "3.2.2" % "test", - "org.scalatest" %% "scalatest" % "3.2.2" % "test", - "org.scalameta" %% "scalameta" % "4.4.27", - "org.scalameta" %% "contrib" % "4.1.6", - "org.typelevel" %% "cats-core" % "2.3.1", - "org.typelevel" %% "cats-free" % "2.3.1", - "org.typelevel" %% "cats-effect" % "2.3.1" + "commons-io"% "commons-io" % "2.19.0", + "org.combinators" %% "templating" % "1.1.5", + "org.scalactic" %% "scalactic" % "3.2.19" % "test", + "org.scalatest" %% "scalatest" % "3.2.19" % "test", + "org.typelevel" %% "cats-core" % "2.13.0", + "org.typelevel" %% "cats-free" % "2.13.0", + "org.typelevel" %% "cats-effect" % "3.6.1" ), evictionErrorLevel := Level.Info, - - addCompilerPlugin("org.typelevel" %% "kind-projector" % "0.10.3") +) + +lazy val publishSettings = Seq( + homepage := Some(url("https://combinators.org")), + licenses := Seq("Apache 2" -> url("http://www.apache.org/licenses/LICENSE-2.0.txt")), + scmInfo := Some(ScmInfo(url("https://www.github.com/combinators/expression-problem"), "scm:git:git@github.com:combinators/expression-problem.git")), + developers := List( + Developer("JanBessai", "Jan Bessai", "jan.bessai@tu-dortmund.de", url("http://noprotocol.net")), + Developer("heineman", "George T. Heineman", "heineman@wpi.edu", url("http://www.cs.wpi.edu/~heineman")), + Developer("BorisDuedder", "Boris Düdder", "boris.d@di.ku.dk", url("http://duedder.net")) + ), + publishTo := sonatypePublishToBundle.value, + ThisBuild / sonatypeCredentialHost := sonatypeCentralHost, +) ++ sys.env.get("PGP_KEY_HEX").map(h => usePgpKeyHex(h)).seq + +lazy val noPublishSettings = Seq( + publish := Seq.empty, + publishLocal := Seq.empty, + publishArtifact := false ) +/** The code generation infrastructure used in languages. + * Things in here are (DI, LI, AI). + */ +lazy val cogen = (Project(id = "cogen", base = file("cogen"))) + .settings(commonSettings: _*) + .settings( + moduleName := "expression-problem-cogen", + ) ++ publishSettings + + /** The core components to model expression problem code generators and domains. * Things in here are (DI, LI, AI). */ @@ -48,9 +69,16 @@ lazy val core = (Project(id = "core", base = file("core"))) .settings(commonSettings: _*) .settings( moduleName := "expression-problem-core", - //addCompilerPlugin("org.typelevel" %% "kind-projector" % "0.10.3"), - addCompilerPlugin("com.olegpy" %% "better-monadic-for" % "0.3.1") ) + .dependsOn(cogen) + +lazy val approach = (Project(id = "approach", base = file("approach"))) + .settings(commonSettings: _*) + .settings( + moduleName := "expression-problem-approach", + ) + .dependsOn(cogen, core) + /** Template for a subproject for a specific domain named `domainName`. * These projects should be (DD, LI, AI). @@ -61,7 +89,7 @@ def standardDomainProject(domainName: String): Project = .settings( moduleName := s"expression-problem-domain-$domainName" ) - .dependsOn(core) + .dependsOn(cogen, core) /** The domain of math with arithmetic expressions. **/ lazy val domainMath = standardDomainProject("math") @@ -77,14 +105,11 @@ def standardLanguageProject(languageName: String): Project = .settings( moduleName := s"expression-problem-language-$languageName", ) - .dependsOn(core, domainMath, domainShape) + .dependsOn(cogen) lazy val languageJava = standardLanguageProject("java") - .settings(libraryDependencies += "com.github.javaparser" % "javaparser-core" % "3.19.0") - .settings( - Compile/run/mainClass := Some("org.combinators.ep.language.java.GenerateAll") - ) + .settings(libraryDependencies += "com.github.javaparser" % "javaparser-core" % "3.26.4") lazy val helloWorldProject: Project = (Project(id = s"helloWorld", base = file(s"helloworld"))) @@ -92,27 +117,21 @@ lazy val helloWorldProject: Project = .settings( moduleName := s"expression-problem-language-helloworld", ) - .dependsOn(core, languageJava, languageNewScala) + .dependsOn(cogen, languageJava, languageNewScala) -lazy val exitSBT = - standardLanguageProject("java") - .settings(libraryDependencies += "com.github.javaparser" % "javaparser-core" % "3.19.0") - .settings( - Compile/run/mainClass := Some("org.combinators.ep.language.java.Exit") - ) lazy val languageInbetween = standardLanguageProject("inbetween") - .dependsOn(core) lazy val languageNewScala = standardLanguageProject("newScala") .dependsOn(languageInbetween) + +lazy val builder = + (Project(id = s"builder", base = file(s"builder"))) + .settings(commonSettings: _*) .settings( - Compile/run/mainClass := Some("org.combinators.ep.language.scala.codegen.GenerateAll") + moduleName := s"expression-problem-language-builder", ) - -//lazy val languageGJ = standardLanguageProject("gj") -//lazy val languageCPP = standardLanguageProject("cpp") -//lazy val languageHaskell = standardLanguageProject("haskell") + .dependsOn(core, cogen, approach, domainMath, domainShape, languageJava, languageNewScala, helloWorldProject) diff --git a/language/java/src/main/resources/java-code/org/combinators/ep/util/Leaf.java b/builder/src/main/resources/java-code/org/combinators/ep/util/Leaf.java similarity index 100% rename from language/java/src/main/resources/java-code/org/combinators/ep/util/Leaf.java rename to builder/src/main/resources/java-code/org/combinators/ep/util/Leaf.java diff --git a/language/java/src/main/resources/java-code/org/combinators/ep/util/Node.java b/builder/src/main/resources/java-code/org/combinators/ep/util/Node.java similarity index 100% rename from language/java/src/main/resources/java-code/org/combinators/ep/util/Node.java rename to builder/src/main/resources/java-code/org/combinators/ep/util/Node.java diff --git a/language/java/src/main/resources/java-code/org/combinators/ep/util/Tree.java b/builder/src/main/resources/java-code/org/combinators/ep/util/Tree.java similarity index 100% rename from language/java/src/main/resources/java-code/org/combinators/ep/util/Tree.java rename to builder/src/main/resources/java-code/org/combinators/ep/util/Tree.java diff --git a/language/newScala/src/main/resources/scala-code/org/combinators/ep/util/Trees.scala b/builder/src/main/resources/scala-code/org/combinators/ep/util/Trees.scala similarity index 100% rename from language/newScala/src/main/resources/scala-code/org/combinators/ep/util/Trees.scala rename to builder/src/main/resources/scala-code/org/combinators/ep/util/Trees.scala diff --git a/builder/src/main/scala/org/combinators/ep/builder/inbetween/paradigm/ffi/Trees.scala b/builder/src/main/scala/org/combinators/ep/builder/inbetween/paradigm/ffi/Trees.scala new file mode 100644 index 00000000..0b42a4e0 --- /dev/null +++ b/builder/src/main/scala/org/combinators/ep/builder/inbetween/paradigm/ffi/Trees.scala @@ -0,0 +1,61 @@ +package org.combinators.ep.builder.inbetween.paradigm.ffi + +/*DI:LI:AI*/ + +import org.combinators.cogen.Command.Generator +import org.combinators.ep.language.inbetween.any.AnyParadigm +import org.combinators.ep.language.inbetween.{any, polymorphism} +import org.combinators.cogen.paradigm.Apply +import org.combinators.ep.generator.paradigm.ffi.{CreateLeaf, CreateNode, Trees as Trs} +import org.combinators.cogen.paradigm.AnyParadigm.syntax +import org.combinators.cogen.{Command, FileWithPath, TypeRep, Understands} +import org.combinators.ep.domain.abstractions.DomainTpeRep + +trait Trees[AST <: TreesAST, B, Context](val base: AnyParadigm.WithAST[AST] & B) extends Trs[Context] { + import base.ast.treesOpsFactory + import base.ast.any + val treeLibrary: Seq[FileWithPath] + def addContextTypeLookup(tpe: TypeRep, lookup: any.Type): Generator[any.Project, Unit] + + override val treeCapabilities: TreeCapabilities = new TreeCapabilities { + implicit val canCreateLeaf: Understands[Context, Apply[CreateLeaf[any.Type], any.Expression, any.Expression]] = + new Understands[Context, Apply[CreateLeaf[any.Type], any.Expression, any.Expression]] { + def perform(context: Context, command: Apply[CreateLeaf[any.Type], any.Expression, any.Expression]): (Context, any.Expression) = { + (context, treesOpsFactory.createLeaf(command.functional.valueType, command.arguments.head)) + } + } + implicit val canCreateNode: Understands[Context, Apply[CreateNode, any.Expression, any.Expression]] = + new Understands[Context, Apply[CreateNode, any.Expression, any.Expression]] { + def perform(context: Context, command: Apply[CreateNode, any.Expression, any.Expression]): (Context, any.Expression) = { + (context, treesOpsFactory.createNode(command.arguments.head, command.arguments.tail)) + } + } + } + + override def enable(): Generator[any.Project, Unit] = { + import base.projectCapabilities.* + import syntax.forEach + for { + _ <- forEach(treeLibrary){ treeLibraryFile => + addCustomFile(treeLibraryFile) + } + nodeTpe <- Command.lift(treesOpsFactory.node()) + _ <- addContextTypeLookup(DomainTpeRep.Tree, nodeTpe) + } yield () + } +} + +object Trees { + + type WithBase[AST <: TreesAST, B <: AnyParadigm.WithAST[AST], Context] = Trees[AST, B, Context] {} + + def apply[AST <: TreesAST, B <: AnyParadigm.WithAST[AST], Context]( + _base: B)( + _treeLibrary: Seq[FileWithPath], + _addContextTypeLookup: (tpe: TypeRep, lookup: _base.ast.any.Type) => Generator[_base.ast.any.Project, Unit] + ): WithBase[AST, _base.type, Context] = new Trees[AST, _base.type, Context](_base) { + override val treeLibrary: _treeLibrary.type = _treeLibrary + override def addContextTypeLookup(tpe: TypeRep, lookup: base.ast.any.Type): Generator[base.ast.any.Project, Unit] = _addContextTypeLookup(tpe, lookup) + } +} + diff --git a/builder/src/main/scala/org/combinators/ep/builder/inbetween/paradigm/ffi/TreesAST.scala b/builder/src/main/scala/org/combinators/ep/builder/inbetween/paradigm/ffi/TreesAST.scala new file mode 100644 index 00000000..2a4348f2 --- /dev/null +++ b/builder/src/main/scala/org/combinators/ep/builder/inbetween/paradigm/ffi/TreesAST.scala @@ -0,0 +1,44 @@ +package org.combinators.ep.builder.inbetween.paradigm.ffi + +import org.combinators.ep.language.inbetween.ffi.OperatorExpressionOpsAST +import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphismAST + +trait TreesAST extends ParametricPolymorphismAST { + object treesOps { + trait FinalTypes { + type Tree <: treesOps.Tree + type Leaf <: treesOps.Leaf + type Node <: treesOps.Node + } + + trait Tree extends any.Type { + def getSelfTree: treesOpsFinalTypes.Tree + } + + trait Leaf extends any.Type { + def getSelfLeaf: treesOpsFinalTypes.Leaf + } + + trait Node extends any.Type { + def getSelfNode: treesOpsFinalTypes.Node + } + + trait Factory { + def tree(): Tree + def node(): Node + def leaf(): Leaf + + def createNode(label: any.Expression, children: Seq[any.Expression]): any.ApplyExpression = + factory.applyExpression(polymorphismFactory.typeReferenceExpression(node()), label +: children) + + def createLeaf(tpe: any.Type, value: any.Expression): any.ApplyExpression = + factory.applyExpression(polymorphismFactory.typeReferenceExpression(polymorphismFactory.typeApplication(leaf(), Seq(tpe))), Seq(value)) + + implicit def convert(other: Tree): treesOpsFinalTypes.Tree = other.getSelfTree + implicit def convert(other: Leaf): treesOpsFinalTypes.Leaf = other.getSelfLeaf + implicit def convert(other: Node): treesOps.Node = other.getSelfNode + } + } + val treesOpsFinalTypes: treesOps.FinalTypes + val treesOpsFactory: treesOps.Factory +} \ No newline at end of file diff --git a/builder/src/main/scala/org/combinators/ep/builder/java/CodeGenerator.scala b/builder/src/main/scala/org/combinators/ep/builder/java/CodeGenerator.scala new file mode 100644 index 00000000..78823673 --- /dev/null +++ b/builder/src/main/scala/org/combinators/ep/builder/java/CodeGenerator.scala @@ -0,0 +1,29 @@ +package org.combinators.ep.builder.java + +import com.github.javaparser.ast.PackageDeclaration +import org.combinators.cogen.Command +import org.combinators.ep.builder.java.paradigm.ffi.Trees +import org.combinators.ep.language.java.{Config, CtorCtxt, MethodBodyCtxt} +import org.combinators.ep.language.java.paradigm.ObjectOriented + +class CodeGenerator(config: Config) extends org.combinators.ep.language.java.CodeGenerator(config) { + + val treesInMethod = { + Trees[MethodBodyCtxt, paradigm.type, ObjectOriented]( + paradigm, + paradigm.methodBodyCapabilities.canAddImportInMethodBody + )(ooParadigm) + } + + val treesInConstructor = { + Trees[CtorCtxt, paradigm.type, ObjectOriented]( + paradigm, + ooParadigm.constructorCapabilities.canAddImportInConstructor + )(ooParadigm) + } +} + +object CodeGenerator { + def apply(config: Config = org.combinators.ep.language.java.CodeGenerator.defaultConfig): CodeGenerator = + new CodeGenerator(config) +} diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/Main.scala b/builder/src/main/scala/org/combinators/ep/builder/java/Main.scala similarity index 57% rename from language/java/src/main/scala/org/combinators/ep/language/java/Main.scala rename to builder/src/main/scala/org/combinators/ep/builder/java/Main.scala index aa289d20..506899b5 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/Main.scala +++ b/builder/src/main/scala/org/combinators/ep/builder/java/Main.scala @@ -1,65 +1,71 @@ -package org.combinators.ep.language.java /*DD:LD:AD*/ +package org.combinators.ep.builder.java + +/*DD:LD:AD*/ /** - * 1. To generate a single approach for a single stage in an Extension Graph, see [[DirectToDiskMain]] - * which you can either modify directly in the editor and execute, or from the command line, type: - * - * ```sbt "language-java/runMain org.combinators.ep.language.java.DirectToDiskMain APPROACH EIP"``` - * - * APPROACH is one of: graphviz, oo, visitor, visitorSideEffect, extensibleVisitor - * interpreter, coco, trivially, dispatch, algebra - * - * EIP is one of the many designated stages: - * - * D1,D2,D1D2,D3,I1,I2,J1,J2,J3,J4,J5,J6,K2J6,J7,J8,K1,K2,X1,X2,X3,X2X3,X4,A1,A1M3,A3M3I2,A3,C2, - * I2M3I1N1,M0,M1,M2,M2_M3,M3I1,M3W1,M4,M5,M6,M7,M7I2,M8,M9,N1,P1,Q1,V1,W1 - * - * 2. To generate all evolution stages for a single approach, see [[GenerateAllForOneApproach]] - * - * ```sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllForOneApproach APPROACH"``` - * - * If you omit the APPROACH argument, then "oo" is the default. - * - * 3. To generate all evolution stages for all systems and approaches, see [[GenerateAll]] - * - * ```sbt "language-java/runMain org.combinators.ep.language.java.GenerateAll"``` - * - * This will generate directories in target/ with names starting with "ep-java" - * - * 4. To generate a quick validation for the latest stage in each system, see [[QuickValidation]] - * - * ```sbt "language-java/runMain org.combinators.ep.language.java.QuickValidation"``` - * - * This one is suitable to compile and confirm no errors as part of a CI/CD. - */ + * 1. To generate a single approach for a single stage in an Extension Graph, see [[DirectToDiskMain]] + * which you can either modify directly in the editor and execute, or from the command line, type: + * + * ```sbt "language-java/runMain org.combinators.ep.language.java.DirectToDiskMain APPROACH EIP"``` + * + * APPROACH is one of: graphviz, oo, visitor, visitorSideEffect, extensibleVisitor + * interpreter, coco, trivially, dispatch, algebra + * + * EIP is one of the many designated stages: + * + * D1,D2,D1D2,D3,I1,I2,J1,J2,J3,J4,J5,J6,K2J6,J7,J8,K1,K2,X1,X2,X3,X2X3,X4,A1,A1M3,A3M3I2,A3,C2, + * I2M3I1N1,M0,M1,M2,M2_M3,M3I1,M3W1,M4,M5,M6,M7,M7I2,M8,M9,N1,P1,Q1,V1,W1 + * + * 2. To generate all evolution stages for a single approach, see [[GenerateAllForOneApproach]] + * + * ```sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllForOneApproach APPROACH"``` + * + * If you omit the APPROACH argument, then "oo" is the default. + * + * 3. To generate all evolution stages for all systems and approaches, see [[GenerateAll]] + * + * ```sbt "language-java/runMain org.combinators.ep.language.java.GenerateAll"``` + * + * This will generate directories in target/ with names starting with "ep-java" + * + * 4. To generate a quick validation for the latest stage in each system, see [[QuickValidation]] + * + * ```sbt "language-java/runMain org.combinators.ep.language.java.QuickValidation"``` + * + * This one is suitable to compile and confirm no errors as part of a CI/CD. + */ import cats.effect.{ExitCode, IO, IOApp} -import org.combinators.ep.approach.oo.{CoCoClean, ExtensibleVisitor, Interpreter, ObjectAlgebras, RuntimeDispatch, Traditional, TriviallyClean, Visitor, Visualize} -import org.combinators.ep.domain.Evolution -import org.combinators.ep.domain.math._ -import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider, FileWithPath, FileWithPathPersistable, TestImplementationProvider} -import org.combinators.jgitserv.{BranchTransaction, GitService} -import FileWithPathPersistable._ import org.apache.commons.io.FileUtils -import org.combinators.ep.approach.oo.Visualize.WithParadigm +import org.combinators.cogen.FileWithPathPersistable.* +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import org.combinators.ep.approach.oo.* +import org.combinators.ep.approach.oo.Visualize +import org.combinators.ep.builder.* +import org.combinators.ep.domain.Evolution +import org.combinators.ep.domain.math.* +import org.combinators.ep.domain.math.{eips} import org.combinators.ep.domain.math.systemD.{D1, D1D2, D2, D3} -import org.combinators.ep.domain.math.{M0, eips} import org.combinators.ep.domain.math.systemI.{I1, I2} -import org.combinators.ep.domain.math.systemJ.{J1, J2, J3, J4, J5, J6} +import org.combinators.ep.domain.math.systemJ.* import org.combinators.ep.domain.math.systemJK.{J7, J8, K2J6} import org.combinators.ep.domain.math.systemK.{K1, K2} -import org.combinators.ep.domain.math.systemO.{O1, O1OA, O2, OA, OD1, OD2, OD3, OO1, OO2, OO3} -import org.combinators.ep.domain.math.systemX.{X1, X2, X2X3, X3, X4} +import org.combinators.ep.domain.math.systemO.* +import org.combinators.ep.domain.math.systemX.* +import org.combinators.ep.domain.shape.{S0, S1, S2, eips => shapeEips} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider, TestImplementationProvider} +import org.combinators.ep.builder.java.paradigm.ffi.Trees +import org.combinators.ep.language.java.{CodeGenerator => CG, JavaNameProvider, PartiallyBoxed, Syntax} -import java.nio.file.{Path, Paths} +import _root_.java.nio.file.{Path, Paths} /** - * Eventually encode a set of subclasses/traits to be able to easily specify (a) the variation; and (b) the evolution. - */ -class Main(choice:String, select:String) { - val generator: CodeGenerator = CodeGenerator(CodeGenerator.defaultConfig.copy(boxLevel = PartiallyBoxed)) + * Eventually encode a set of subclasses/traits to be able to easily specify (a) the variation; and (b) the evolution. + */ +class Main(choice: String, select: String) { + val generator: CodeGenerator = CodeGenerator(CG.defaultConfig.copy(boxLevel = PartiallyBoxed)) - val visualizeApproach: WithParadigm[generator.paradigm.type] = Visualize[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm) + val visualizeApproach: Visualize.WithParadigm[generator.paradigm.type] = Visualize[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm) val ooApproach: Traditional.WithParadigm[generator.paradigm.type] = Traditional[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm) @@ -75,7 +81,7 @@ class Main(choice:String, select:String) { val algebraApproach: ObjectAlgebras.WithParadigm[generator.paradigm.type] = ObjectAlgebras[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) // select one here - val approach = choice match { + val approach: ApproachImplementationProvider.WithParadigm[generator.paradigm.type] = choice match { case "graphviz" => visualizeApproach case "oo" => ooApproach case "visitor" => visitorApproach @@ -91,7 +97,7 @@ class Main(choice:String, select:String) { } val m0_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M0(approach.paradigm)(generator.doublesInMethod,generator.stringsInMethod) + eips.M0(approach.paradigm)(generator.doublesInMethod, generator.stringsInMethod) val m1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.M1(approach.paradigm)(m0_eip)(generator.doublesInMethod) val m2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = @@ -123,10 +129,10 @@ class Main(choice:String, select:String) { eips.systemO.OO3(approach.paradigm)(oo1_eip, oo2_eip) val m4_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M4.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip)( + eips.M4.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip)( generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod, generator.listsInMethod, generator.equalityInMethod) val m5_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M5(approach.paradigm)(m4_eip)(generator.intsInMethod,generator.treesInMethod) + eips.M5(approach.paradigm)(m4_eip)(generator.intsInMethod, generator.treesInMethod) val m6_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.M6(approach.paradigm)(m5_eip)(generator.equalityInMethod, generator.booleansInMethod) val m7_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = @@ -136,11 +142,11 @@ class Main(choice:String, select:String) { val i2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemI.I2(approach.paradigm)(i1_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.stringsInMethod) val m7i2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M7I2.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7_eip,i2_eip)( - generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod) + eips.M7I2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7_eip, i2_eip)( + generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod) val m8_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M8.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7i2_eip)( - generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) + eips.M8.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7i2_eip)( + generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) val m9_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.M9(approach.paradigm)(m8_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.imperativeInMethod) @@ -154,30 +160,30 @@ class Main(choice:String, select:String) { eips.A3(approach.paradigm)(a1m3i2_eip)(generator.doublesInMethod, generator.stringsInMethod) val j1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJ.J1(approach.paradigm)(m0_eip)(generator.doublesInMethod,generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) + eips.systemJ.J1(approach.paradigm)(m0_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) val j2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJ.J2(approach.paradigm)(j1_eip)(generator.doublesInMethod,generator.booleansInMethod, generator.equalityInMethod) + eips.systemJ.J2(approach.paradigm)(j1_eip)(generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod) val j3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJ.J3(approach.paradigm)(j2_eip)(generator.doublesInMethod,generator.booleansInMethod, generator.stringsInMethod) + eips.systemJ.J3(approach.paradigm)(j2_eip)(generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod) val k1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemK.K1(approach.paradigm)(j2_eip)(generator.doublesInMethod,generator.realDoublesInMethod, generator.booleansInMethod, generator.stringsInMethod) + eips.systemK.K1(approach.paradigm)(j2_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.booleansInMethod, generator.stringsInMethod) val j4_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJ.J4(approach.paradigm)(j3_eip)(generator.intsInMethod,generator.treesInMethod) + eips.systemJ.J4(approach.paradigm)(j3_eip)(generator.intsInMethod, generator.treesInMethod) val j5_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJ.J5(approach.paradigm)(j4_eip)(generator.equalityInMethod,generator.booleansInMethod) + eips.systemJ.J5(approach.paradigm)(j4_eip)(generator.equalityInMethod, generator.booleansInMethod) val j6_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJ.J6(approach.paradigm)(j5_eip)(generator.doublesInMethod,generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) + eips.systemJ.J6(approach.paradigm)(j5_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) val k2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemK.K2.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(k1_eip)( + eips.systemK.K2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(k1_eip)( generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod, generator.listsInMethod, generator.equalityInMethod) val k2j6_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJK.K2J6.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(j6_eip,k2_eip)( + eips.systemJK.K2J6.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(j6_eip, k2_eip)( generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod, generator.equalityInMethod) val j7_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemJK.J7.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(k2j6_eip)( + eips.systemJK.J7.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(k2j6_eip)( generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod, generator.equalityInMethod) val j8_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemJK.J8(approach.paradigm)(j7_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.imperativeInMethod) @@ -186,21 +192,21 @@ class Main(choice:String, select:String) { eips.W1(approach.paradigm)(m1_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.stringsInMethod) val m3w1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M3W1.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip,w1_eip)( - generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod + eips.M3W1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip, w1_eip)( + generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod ) val q1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.Q1(approach.paradigm)(m3w1_eip)(generator.intsInMethod, generator.realDoublesInMethod, generator.treesInMethod, generator.stringsInMethod) val c2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.C2.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(q1_eip)( - generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod, generator.listsInMethod, generator.equalityInMethod) + eips.C2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(q1_eip)( + generator.doublesInMethod, generator.booleansInMethod, generator.stringsInMethod, generator.listsInMethod, generator.equalityInMethod) - val v1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.V1.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(c2_eip)( - generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) + val v1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.V1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(c2_eip)( + generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) val x1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemX.X1(approach.paradigm)(m0_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) + eips.systemX.X1(approach.paradigm)(m0_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) val x2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemX.X2(approach.paradigm)(x1_eip)(generator.doublesInMethod, generator.stringsInMethod) val x3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = @@ -213,32 +219,46 @@ class Main(choice:String, select:String) { eips.systemX.X4(approach.paradigm)(x2x3_eip)(generator.doublesInMethod, generator.stringsInMethod) val m2_abs_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M2_ABS.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m2_eip)( + eips.M2_ABS.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m2_eip)( generator.imperativeInMethod, generator.doublesInMethod, generator.stringsInMethod) val m3i1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M3I1.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip,i1_eip)( - generator.imperativeInMethod, generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) + eips.M3I1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip, i1_eip)( + generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) val n1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.N1(approach.paradigm)(m3_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) val i2m3i1n1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.I2M3I1N1.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(i2_eip,m3i1_eip,n1_eip)( + eips.I2M3I1N1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(i2_eip, m3i1_eip, n1_eip)( generator.booleansInMethod, generator.equalityInMethod, generator.stringsInMethod) val d1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemD.D1(approach.paradigm)(m1_eip)(generator.doublesInMethod, generator.realDoublesInMethod, generator.equalityInMethod, generator.stringsInMethod, generator.imperativeInMethod) val d2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemD.D2(approach.paradigm)(m1_eip)(generator.doublesInMethod, generator.stringsInMethod) + eips.systemD.D2(approach.paradigm)(m1_eip)(generator.doublesInMethod) val d1d2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemD.D1D2.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(d1_eip,d2_eip)( - generator.imperativeInMethod, generator.doublesInMethod, generator.booleansInMethod, generator.equalityInMethod) + eips.systemD.D1D2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(d1_eip, d2_eip) val d3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemD.D3(approach.paradigm)(d1d2_eip)(generator.doublesInMethod, generator.stringsInMethod) + val s0_eip = + shapeEips.S0(approach.paradigm)( + ffiArithmetic = generator.doublesInMethod, + generator.realDoublesInMethod, + generator.booleansInMethod, + generator.stringsInMethod + ) + val s1_eip = shapeEips.S1(approach.paradigm)(s0_eip)( + generator.doublesInMethod, + generator.booleansInMethod + ) + val s2_eip = shapeEips.S2(approach.paradigm)(s1_eip)( + generator.doublesInMethod, + generator.imperativeInMethod + ) val evolutions: Seq[Evolution] = select match { case "M0" => Seq(M0) @@ -308,6 +328,11 @@ class Main(choice:String, select:String) { case "D1D2" => Seq(M0, M1, D1, D2, D1D2) case "D3" => Seq(M0, M1, D1, D2, D1D2, D3) + // Shapes + case "S0" => Seq(S0) + case "S1" => Seq(S0, S1) + case "S2" => Seq(S0, S1, S2) + case _ => ??? } @@ -378,6 +403,11 @@ class Main(choice:String, select:String) { case "D1D2" => d1d2_eip case "D3" => d3_eip + // Shapes + case "S0" => s0_eip + case "S1" => s1_eip + case "S2" => s2_eip + case _ => ??? } @@ -399,14 +429,6 @@ class Main(choice:String, select:String) { val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] - def gitTransaction: Option[BranchTransaction] = - transaction[Option[BranchTransaction]](Option.empty, (transaction, evolutionName, files) => { - val nextTransaction = - transaction.map(_.fork(evolutionName).deleteAllFiles) - .getOrElse(BranchTransaction.empty(evolutionName)) - Some(nextTransaction.persist(files())(persistable).commit("Adding next evolution")) - }) - def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { transaction[IO[Unit]](IO.unit, (transaction, evolutionName, files) => IO { print("Computing Files...") @@ -423,15 +445,6 @@ class Main(choice:String, select:String) { }) } - def runGit(args: List[String]): IO[ExitCode] = { - val name = evolutions.head.getModel.base.name - for { - _ <- IO { System.out.println(s"Use: git clone http://127.0.0.1:8081/$name ${evolutions.last.getModel.name}") } - exitCode <- new GitService(gitTransaction.toSeq, name).run(args) - //exitCode <- new GitService(transaction.toSeq, name).runProcess(Seq(s"sbt", "test")) - } yield exitCode - } - def runDirectToDisc(targetDirectory: Path): IO[ExitCode] = { for { _ <- directToDiskTransaction(targetDirectory) @@ -439,57 +452,109 @@ class Main(choice:String, select:String) { } } -object GitMain extends IOApp { +trait Subselection extends IOApp { + def approaches(args: List[String]): Seq[String] + val evolutions: Seq[String] + def target(args: List[String]): String - def run(args: List[String]): IO[ExitCode] = { - val approach = if (args.isEmpty) "interpreter" else args.head - val selection = if (args.isEmpty || args.tail.isEmpty) "M7I2" else args.tail.head - new Main(approach, selection).runGit(args) + override def run(args: List[String]): IO[ExitCode] = { + val target = this.target(args) + val results = approaches(args).foldLeft(IO.unit)((results, approach) => { + val printApproach = IO { + println("Generating " + approach + "...") + } + evolutions.foldLeft(results)((results, selection) => { + val targetDirectory = Paths.get("target", target, approach, selection) + val program: IO[Unit] = { + for { + _ <- IO { + println(" " + selection) + } + _ <- results + _ <- IO { + print("Initializing Generator...") + } + main <- IO { + new Main(approach, selection) + } + + _ <- IO { + println("[OK]") + } + _ <- main.runDirectToDisc(targetDirectory) + } yield () + } + for { + _ <- printApproach + _ <- program + } yield () + + // execute above as a stand-alone program + + // TBD: Would be nice to launch 'sbt' in each of these generated directories + }) + }) + + for { + _ <- results + _ <- IO { + print("DONE") + } + } yield ExitCode.Success } -} -// FAILS for OO3 since need finalized to pull everything together from independent branches -// that each have operations which need to be merged. + +} object DirectToDiskMain extends IOApp { val targetDirectory: Path = Paths.get("target", "java-out") def run(args: List[String]): IO[ExitCode] = { // "M9", "J8", "A3", "O1OA", "OD3", "OO3", "V1", "D3", "I2M3I1N1", "O2" - val approach = if (args.isEmpty) "dispatch" else args.head // {coco, O1OA} fails - if (approach == "exit") { sys.exit(0) } - val selection = if (args.isEmpty || args.tail.isEmpty) "J4" else args.tail.head + val approach = if (args.isEmpty) "oo" else args.head // {coco, O1OA} fails + if (approach == "exit") { + sys.exit(0) + } + + // M4 exception for 'oo' + val selection = if (args.isEmpty || args.tail.isEmpty) "M5" else args.tail.head println("Generating " + approach + " for " + selection) val main = new Main(approach, selection) for { - _ <- IO { print("Initializing Generator...") } - main <- IO { main } + _ <- IO { + print("Initializing Generator...") + } + main <- IO { + main + } - _ <- IO { println("[OK]") } + _ <- IO { + println("[OK]") + } result <- main.runDirectToDisc(targetDirectory) } yield result } } /** - * Generate ALL CODE. - */ + * Generate ALL CODE. + */ object GenerateAll extends IOApp { - def run(args: List[String]): IO[ExitCode] = { - GenerateAllMain.run(List.empty) - GenerateAllExtended.run(List.empty) - GenerateAllThirdAlternate.run(List.empty) - GenerateAllD1D2.run(List.empty) - GenerateAllMerging.run(List.empty) - GenerateAllJ.run(List.empty) - } + def run(args: List[String]): IO[ExitCode] = for { + _ <- GenerateAllMain.run(List.empty) + _ <- GenerateAllExtended.run(List.empty) + _ <- GenerateAllThirdAlternate.run(List.empty) + _ <- GenerateAllD1D2.run(List.empty) + _ <- GenerateAllMerging.run(List.empty) + r <- GenerateAllJ.run(List.empty) + } yield r } /** - * Generate ALL CODE just for one approach (as identified) - */ + * Generate ALL CODE just for one approach (as identified) + */ object GenerateAllForOneApproach extends IOApp { def run(args: List[String]): IO[ExitCode] = { @@ -499,341 +564,149 @@ object GenerateAllForOneApproach extends IOApp { args } - GenerateAllMain.run(approach) - GenerateAllExtended.run(approach) - GenerateAllThirdAlternate.run(approach) - GenerateAllD1D2.run(approach) - GenerateAllMerging.run(approach) - GenerateAllJ.run(approach) + for { + _ <- GenerateAllMain.run(approach) + _ <- GenerateAllExtended.run(approach) + _ <- GenerateAllThirdAlternate.run(approach) + _ <- GenerateAllD1D2.run(approach) + _ <- GenerateAllMerging.run(approach) + r <- GenerateAllJ.run(approach) + } yield r } } -object QuickValidation extends IOApp { + +object QuickValidation extends Subselection { + // note that visitorSideEffect and dispatch are omitted from this validation. VISITORSIDEEFFECT has a problem // with the test cases in that the methods become too long for the JavaVM and attempts to subdivide them fail // because visitorSideEffect needs to create visitor objects, and arbitrarily splitting test cases means that // they are not properly scoped and so the code fails to compile. DISPATCH is omitted because the inBetween // does not yet have exceptions. - def run(args: List[String]): IO[ExitCode] = { - val approaches = if (args.isEmpty) { - Seq("trivially", "oo", "visitor", "extensibleVisitor", "interpreter", "coco", "algebra") - } else { - args - } - - val target = "ep-java-quick" - - // latest in all system families - val evolutions = Seq("M9", "J8", "A3", "O1OA", "OD3", "OO3", "V1", "D3", "I2M3I1N1", "O2") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("trivially", "oo", "visitor", "extensibleVisitor", "interpreter", "coco", "algebra") + } else { + args } -} - -object GenerateAllMain extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-java" - } else { - args.head - } - val evolutions = Seq("M0","M1","M2","M3","M4","M5","M6","M7","M7I2","M8","M9","I1","A1","A1M3","A1M3I2","A3","I2", - "O1","O2","OA","O1OA","OD1","OD2","OD3","OO1","OO2","OO3") - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) + def target(args: List[String]): String = "ep-java-quick" - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } + // latest in all system families + val evolutions = Seq("M9", "J8", "A3", "O1OA", "OD3", "OO3", "V1", "D3", "I2M3I1N1", "O2") - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success - - } } -object GenerateAllJ extends IOApp { +object GenerateAllMain extends Subselection { - def run(args: List[String]): IO[ExitCode] = { - // visitor side effect is eliminated. When there are a large number of test cases, the internal - // code separates arbitrarily these test cases into 500-line chunks. Unfortunately for the - // visitorSideEffect, this causes problems because local variables are used for the visitors and - // they are unreachable when split across multiple methods. - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-java-j" - } else { - args.head - } - val evolutions = Seq("M0","J1","J2","J3","K1","K2","J4","J5","J6","K2J6","J7","J8") + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java" + } else { + args.head + } + val evolutions = Seq("M0", "M1", "M2", "M3", "M4", "M5", "M6", "M7", "M7I2", "M8", "M9", "I1", "A1", "A1M3", "A1M3I2", "A3", "I2", + "O1", "O2", "OA", "O1OA", "OD1", "OD2", "OD3", "OO1", "OO2", "OO3") - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) +} - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } +object GenerateAllJ extends Subselection { - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - // execute above as a stand-alone program - program.unsafeRunSync() + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java-j" + } else { + args.head + } + val evolutions = Seq("M0", "J1", "J2", "J3", "K1", "K2", "J4", "J5", "J6", "K2J6", "J7", "J8") - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) +} - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success +object GenerateAllD1D2 extends Subselection { + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java-d1d2" + } else { + args.head } + val evolutions = Seq("M0", "M1", "D1", "D2", "D1D2", "D3") } -object GenerateAllD1D2 extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-java-d1d2" - } else { - args.head - } - val evolutions = Seq("M0","M1","D1","D2","D1D2","D3") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success +object GenerateAllMerging extends Subselection { + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java-merging" + } else { + args.head } + val evolutions = Seq("M0", "M1", "M2", "I1", "I2", "N1", "M2_ABS", "M3", "M3I1", "I2M3I1N1") } -object GenerateAllMerging extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-java-merging" - } else { - args.head - } - val evolutions = Seq("M0","M1","M2","I1","I2","N1","M2_ABS","M3","M3I1","I2M3I1N1") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) +object GenerateAllExtended extends Subselection { - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java-extended" + } else { + args.head + } + val evolutions = Seq("M0", "M1", "M2", "M3", "W1", "M3W1", "Q1", "C2", "V1") } -object GenerateAllExtended extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-java-extended" - } else { - args.head - } - val evolutions = Seq("M0","M1","M2","M3","W1","M3W1","Q1","C2","V1") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) +object GenerateAllThirdAlternate extends Subselection { - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java-third-alternate" + } else { + args.head } + val evolutions = Seq("M0", "X1", "X2", "X3", "X2X3", "X4") } -object GenerateAllThirdAlternate extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-java-third-alternate" - } else { - args.head - } - val evolutions = Seq("M0","X1","X2","X3","X2X3","X4") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) +object GenerateShapes extends Subselection { - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-java-shapes" + } else { + args.head } + val evolutions = Seq("S0", "S1", "S2") } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Trees.scala b/builder/src/main/scala/org/combinators/ep/builder/java/paradigm/ffi/Trees.scala similarity index 88% rename from language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Trees.scala rename to builder/src/main/scala/org/combinators/ep/builder/java/paradigm/ffi/Trees.scala index 736ffc74..a7a86325 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Trees.scala +++ b/builder/src/main/scala/org/combinators/ep/builder/java/paradigm/ffi/Trees.scala @@ -1,22 +1,22 @@ -package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ +package org.combinators.ep.builder.java.paradigm.ffi + +/*DI:LD:AI*/ -import java.nio.file.Paths import com.github.javaparser.StaticJavaParser -import com.github.javaparser.ast.{ImportDeclaration, NodeList} import com.github.javaparser.ast.`type`.Type import com.github.javaparser.ast.expr.ObjectCreationExpr -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.tree.{Leaf, Node, Tree} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.{AddImport, Apply} -import org.combinators.ep.generator.paradigm.ffi.{Create, CreateLeaf, CreateNode, Trees => Ts} +import com.github.javaparser.ast.{ImportDeclaration, NodeList} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm.syntax.forEach +import org.combinators.ep.generator.paradigm.ffi.{CreateLeaf, CreateNode, Trees as Ts} +import org.combinators.cogen.paradigm.{AddImport, Apply} +import org.combinators.cogen.{Command, InstanceRep, TypeRep, Understands} +import org.combinators.ep.domain.abstractions.DomainTpeRep +import org.combinators.ep.domain.tree.{Leaf, Node} import org.combinators.ep.language.java.CodeGenerator.Enable -import org.combinators.ep.language.java.{ContextSpecificResolver, ProjectCtxt} +import org.combinators.ep.language.java.Syntax.default.* import org.combinators.ep.language.java.paradigm.{AnyParadigm, Generics, ObjectOriented} -import org.combinators.ep.language.java.Syntax.default._ +import org.combinators.ep.language.java.{ContextSpecificResolver, ProjectCtxt} trait Trees[Ctxt, AP <: AnyParadigm] extends Ts[Ctxt] { case object TreesEnabled @@ -65,7 +65,7 @@ trait Trees[Ctxt, AP <: AnyParadigm] extends Ts[Ctxt] { new ObjectCreationExpr( null, ObjectOriented.nameToType(nodeImport.getName), - new NodeList[Expression](command.arguments: _*) + new NodeList[Expression](command.arguments*) ) Command.runGenerator(gen, context) } @@ -94,7 +94,7 @@ trait Trees[Ctxt, AP <: AnyParadigm] extends Ts[Ctxt] { toResolution: ContextSpecificResolver => TypeRep => Generator[Ctxt, Type], canAddImport: Understands[Ctxt, AddImport[Import]] ): ContextSpecificResolver => TypeRep => Generator[Ctxt, Type] = k => { - case TypeRep.Tree => + case DomainTpeRep.Tree => for { _ <- AddImport(treeImport).interpret(canAddImport) } yield treeType @@ -111,7 +111,7 @@ trait Trees[Ctxt, AP <: AnyParadigm] extends Ts[Ctxt] { case Node(id, elems) => for { elems <- forEach(elems) { elem => - projectReiification(k)(InstanceRep(TypeRep.Tree)(elem)) + projectReiification(k)(InstanceRep(DomainTpeRep.Tree)(elem)) } ident <- projectReiification(k)(InstanceRep(TypeRep.Int)(id)) result <- Apply[CreateNode, Expression, Expression](CreateNode(), ident +: elems).interpret(nodeCreation(canAddImport)) @@ -197,11 +197,12 @@ object Trees { val b: base.type = base val addImp = addImport val oo: ooParadigm.type = ooParadigm + case class T( + val base: b.type, + val addImport: Understands[Ctxt, AddImport[Import]], + val ooParadigm: oo.type + ) extends Trees[Ctxt, b.type] - new Trees[Ctxt, b.type] { - lazy val base: b.type = b - lazy val addImport: Understands[Ctxt, AddImport[Import]] = addImp - lazy val ooParadigm: oo.type = oo - } + T(b, addImport, oo) } } diff --git a/builder/src/main/scala/org/combinators/ep/builder/scala/CodeGenerator.scala b/builder/src/main/scala/org/combinators/ep/builder/scala/CodeGenerator.scala new file mode 100644 index 00000000..823d0dbf --- /dev/null +++ b/builder/src/main/scala/org/combinators/ep/builder/scala/CodeGenerator.scala @@ -0,0 +1,22 @@ +package org.combinators.ep.builder.scala + +//import org.combinators.ep.builder.scala.paradigm.ffi.Trees +//import org.combinators.ep.language.scala.{Config, CtorCtxt, MethodBodyCtxt} +//import org.combinators.ep.language.scala.Metho +//import org.combinators.ep.language.inbetween.CodeGenerator + +class CodeGenerator { +// val treesInMethod = { +// Trees[MethodBodyCtxt, paradigm.type, ObjectOriented]( +// paradigm, +// paradigm.methodBodyCapabilities.canAddImportInMethodBody +// )(ooParadigm) +// } +// +// val treesInConstructor = { +// Trees[CtorCtxt, paradigm.type, ObjectOriented]( +// paradigm, +// ooParadigm.constructorCapabilities.canAddImportInConstructor +// )(ooParadigm) +// } +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/Main.scala b/builder/src/main/scala/org/combinators/ep/builder/scala/Main.scala similarity index 55% rename from language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/Main.scala rename to builder/src/main/scala/org/combinators/ep/builder/scala/Main.scala index d4fd7bf0..24a52ca0 100644 --- a/language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/Main.scala +++ b/builder/src/main/scala/org/combinators/ep/builder/scala/Main.scala @@ -1,4 +1,6 @@ -package org.combinators.ep.language.scala.codegen /*DD:LD:AD*/ +package org.combinators.ep.builder.scala + +/*DD:LD:AD*/ /** * To generate a single approach for a single stage in an Extension Graph, see [[DirectToDiskMain]] @@ -37,10 +39,12 @@ package org.combinators.ep.language.scala.codegen /*DD:LD:AD*/ import cats.effect.{ExitCode, IO, IOApp} import org.apache.commons.io.FileUtils -import org.combinators.ep.approach.oo._ +import org.combinators.cogen.FileWithPathPersistable.* +import org.combinators.cogen.{Command, FileWithPath, FileWithPathPersistable} +import org.combinators.ep.approach.oo.{CoCoClean, ExtensibleVisitor, Interpreter, ObjectAlgebras, Traditional, TriviallyClean, Visitor, Visualize} import org.combinators.ep.domain.Evolution -import org.combinators.ep.domain.math._ -import org.combinators.ep.domain.math.eips.systemX +import org.combinators.ep.domain.math.{A1, A1M3, A1M3I2, A3, C2, I2M3I1N1, M0, M1, M2, M2_ABS, M3, M3I1, M3W1, M4, M5, M6, M7, M7I2, M8, M9, N1, P1, Q1, V1, W1} +import org.combinators.ep.domain.math.eips import org.combinators.ep.domain.math.systemD.{D1, D1D2, D2, D3} import org.combinators.ep.domain.math.systemI.{I1, I2} import org.combinators.ep.domain.math.systemJ.{J1, J2, J3, J4, J5, J6} @@ -49,9 +53,12 @@ import org.combinators.ep.domain.math.systemK.{K1, K2} import org.combinators.ep.domain.math.systemO.{O1, O1OA, O2, OA, OD1, OD2, OD3, OO1, OO2, OO3} import org.combinators.ep.domain.math.systemX.{X1, X2, X2X3, X3, X4} import org.combinators.ep.generator.ApproachImplementationProvider.WithParadigm -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider, FileWithPath, FileWithPathPersistable, TestImplementationProvider} -import org.combinators.jgitserv.{BranchTransaction, GitService} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider, TestImplementationProvider} +import org.combinators.ep.language.scala.codegen.{CodeGenerator, FullAST} +import org.combinators.ep.builder.inbetween.paradigm.ffi.Trees +import org.combinators.ep.language.scala.ast.{FinalBaseAST, FinalNameProviderAST} +import org.combinators.ep.language.scala.ast.ffi.* +import org.combinators.ep.builder.scala.paradigm.ffi.* import java.nio.file.{Path, Paths} @@ -59,14 +66,35 @@ import java.nio.file.{Path, Paths} * Eventually encode a set of subclasses/traits to be able to easily specify (a) the variation; and (b) the evolution. */ class Main(choice:String, select:String) { - val generator: CodeGenerator = CodeGenerator(M0.getModel.base.name.toLowerCase) - - val functionalApproach: WithParadigm[generator.paradigm.type] = org.combinators.ep.approach.functional.Traditional[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl) + val ast: FullAST & TreesAST = new FinalBaseAST + with FinalNameProviderAST + with FinalArithmeticAST + with FinalAssertionsAST + with FinalBooleanAST + with FinalEqualsAST + with FinalListsAST + with FinalOperatorExpressionsAST + with FinalRealArithmeticOpsAST + with FinalStringAST + with FinalTreesAST { + val reificationExtensions = List(scalaTreesOps.treeReificationExtensions) + } + val generator: CodeGenerator[ast.type] = CodeGenerator(M0.getModel.base.name.toLowerCase, ast, ast.scalaTreesOps.treePrefixExcludes) + + val treesInMethod = + Trees[ast.type, generator.paradigm.type, ast.any.Method](generator.paradigm)(ast.scalaTreesOps.treeLibrary, (tpe, lookup) => { + for { + _ <- generator.paradigm.projectCapabilities.addTypeLookupForMethods(tpe, Command.lift(lookup)) + _ <- generator.ooParadigm.projectCapabilities.addTypeLookupForClasses(tpe, Command.lift(lookup)) + _ <- generator.ooParadigm.projectCapabilities.addTypeLookupForConstructors(tpe, Command.lift(lookup)) + } yield () + }) + val functionalApproach: WithParadigm[generator.paradigm.type] = org.combinators.ep.approach.functional.Traditional[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl.functionalControlInMethods) val ooApproach: WithParadigm[generator.paradigm.type] = Traditional[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.ooParadigm) val visitorApproach: Visitor.WithParadigm[generator.paradigm.type] = Visitor[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) - val visitorSideEffectApproach: Visitor.WithParadigm[generator.paradigm.type] = Visitor.withSideEffects[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.imperative, generator.ooParadigm) + val visitorSideEffectApproach: Visitor.WithParadigm[generator.paradigm.type] = Visitor.withSideEffects[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.imperative.imperativeInMethods, generator.ooParadigm) val extensibleVisitorApproach: ExtensibleVisitor.WithParadigm[generator.paradigm.type] = ExtensibleVisitor[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) val interpreterApproach: Interpreter.WithParadigm[generator.paradigm.type] = Interpreter[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) @@ -79,7 +107,7 @@ class Main(choice:String, select:String) { val visualizeApproach: Visualize.WithParadigm[generator.paradigm.type] = Visualize[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.ooParadigm) // select one here - val approach = choice match { + val approach: ApproachImplementationProvider.WithParadigm[generator.paradigm.type] = choice match { case "functional" => functionalApproach case "graphviz" => visualizeApproach case "oo" => ooApproach @@ -168,258 +196,356 @@ class Main(choice:String, select:String) { val m0_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M0(approach.paradigm)(generator.doubles,generator.strings) + eips.M0(approach.paradigm)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val m1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M1(approach.paradigm)(m0_eip)(generator.doubles) + eips.M1(approach.paradigm)(m0_eip)(generator.doubles.arithmeticInMethods) val m2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M2(approach.paradigm)(m1_eip)(generator.doubles, generator.strings) + eips.M2(approach.paradigm)(m1_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val m3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M3(approach.paradigm)(m2_eip)(generator.doubles, generator.strings) + eips.M3(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val m4_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.M4.functional[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.strings, generator.listsInMethod, generator.equality) + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.lists.listsInMethods, + generator.equality.equalsInMethods) } else { eips.M4.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.strings, generator.listsInMethod, generator.equality) + generator.imperative.imperativeInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.lists.listsInMethods, + generator.equality.equalsInMethods) } val m5_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M5(approach.paradigm)(m4_eip)(generator.ints,generator.treesInMethod) + eips.M5(approach.paradigm)(m4_eip)(generator.ints.arithmeticInMethods, treesInMethod) val m6_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.M6(approach.paradigm)(m5_eip)(generator.equality, generator.booleans) + eips.M6(approach.paradigm)(m5_eip)(generator.equality.equalsInMethods, generator.booleans.booleansInMethodsInMethods) val m7_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.M7funct(approach.paradigm)(m6_eip)(generator.functional, generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) - } else { - eips.M7(approach.paradigm)(m6_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.M7funct(approach.paradigm)(m6_eip)( + generator.functional, + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) + } else { + eips.M7(approach.paradigm)(m6_eip)( + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods, + generator.imperative.imperativeInMethods) } val i1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.systemI.I1funct(approach.paradigm)(m2_eip)(generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) - } else { - eips.systemI.I1(approach.paradigm)(m2_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.systemI.I1funct(approach.paradigm)(m2_eip)( + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) + } else { + eips.systemI.I1(approach.paradigm)(m2_eip)( + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods, + generator.imperative.imperativeInMethods) } val i2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemI.I2(approach.paradigm)(i1_eip)(generator.doubles, generator.realDoubles, generator.strings) + eips.systemI.I2(approach.paradigm)(i1_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.strings.stringsInMethods) val m7i2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.M7I2.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7_eip, i2_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.equality) + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.equality.equalsInMethods + ) } else { eips.M7I2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7_eip, i2_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.equality) + generator.imperative.imperativeInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.equality.equalsInMethods + ) } val m8_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.M8.functional[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7i2_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.equality, generator.strings) + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) } else { eips.M8.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m7i2_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.equality,generator.strings) + generator.imperative.imperativeInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) } val m9_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.M9funct(approach.paradigm)(m8_eip)(generator.functionalControl, generator.doubles) + eips.M9funct(approach.paradigm)(m8_eip)(generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods) } else { - eips.M9(approach.paradigm)(m8_eip)(generator.doubles, generator.realDoubles, generator.imperative) + eips.M9(approach.paradigm)(m8_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.imperative.imperativeInMethods) } val a1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.A1(approach.paradigm)(i1_eip)(generator.doubles, generator.strings) + eips.A1(approach.paradigm)(i1_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val a1m3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.A1M3(approach.paradigm)(m3_eip, a1_eip)(generator.strings) + eips.A1M3(approach.paradigm)(m3_eip, a1_eip)(generator.strings.stringsInMethods) val a1m3i2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.A1M3I2(approach.paradigm)(a1m3_eip, i2_eip)(generator.strings) + eips.A1M3I2(approach.paradigm)(a1m3_eip, i2_eip)(generator.strings.stringsInMethods) val a3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.A3(approach.paradigm)(a1m3i2_eip)(generator.doubles, generator.strings) + eips.A3(approach.paradigm)(a1m3i2_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val o1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.O1(approach.paradigm)(m2_eip)(generator.doubles, generator.strings) + eips.systemO.O1(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val oa_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.OA(approach.paradigm)(m2_eip)(generator.doubles) + eips.systemO.OA(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods) val o1oa_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemO.O1OA(approach.paradigm)(o1_eip, oa_eip) val o2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.O2(approach.paradigm)(o1_eip)(generator.doubles, generator.strings) + eips.systemO.O2(approach.paradigm)(o1_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val od1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.OD1(approach.paradigm)(m2_eip)(generator.doubles, generator.strings) + eips.systemO.OD1(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val od2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.OD2(approach.paradigm)(m2_eip)(generator.doubles, generator.strings) + eips.systemO.OD2(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val od3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemO.OD3(approach.paradigm)(od1_eip, od2_eip) val oo1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.OO1(approach.paradigm)(m2_eip)(generator.doubles, generator.realDoubles, generator.strings) + eips.systemO.OO1(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.strings.stringsInMethods) val oo2_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = - eips.systemO.OO2(approach.paradigm)(m2_eip)(generator.doubles, generator.realDoubles, generator.strings) + eips.systemO.OO2(approach.paradigm)(m2_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.strings.stringsInMethods) val oo3_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = eips.systemO.OO3(approach.paradigm)(oo1_eip, oo2_eip) val j1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.systemJ.J1funct(approach.paradigm)(m0_eip)(generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) - } else { - eips.systemJ.J1(approach.paradigm)(m0_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.systemJ.J1funct(approach.paradigm)(m0_eip)( + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) + } else { + eips.systemJ.J1(approach.paradigm)(m0_eip)( + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods, + generator.imperative.imperativeInMethods) } val j2_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemJ.J2(approach.paradigm)(j1_eip)(generator.doubles, generator.booleans, generator.equality) + eips.systemJ.J2(approach.paradigm)(j1_eip)(generator.doubles.arithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods) val j3_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemJ.J3(approach.paradigm)(j2_eip)(generator.doubles, generator.booleans, generator.strings) + eips.systemJ.J3(approach.paradigm)(j2_eip)(generator.doubles.arithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.strings.stringsInMethods) val k1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemK.K1(approach.paradigm)(j2_eip)(generator.doubles, generator.realDoubles, generator.booleans, generator.strings) + eips.systemK.K1(approach.paradigm)(j2_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.strings.stringsInMethods) val j4_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemJ.J4(approach.paradigm)(j3_eip)(generator.ints, generator.treesInMethod) + eips.systemJ.J4(approach.paradigm)(j3_eip)(generator.ints.arithmeticInMethods, treesInMethod) val j5_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemJ.J5(approach.paradigm)(j4_eip)(generator.equality, generator.booleans) + eips.systemJ.J5(approach.paradigm)(j4_eip)(generator.equality.equalsInMethods, generator.booleans.booleansInMethodsInMethods) val j6_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.systemJ.J6funct(approach.paradigm)(j5_eip)(generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) + eips.systemJ.J6funct(approach.paradigm)(j5_eip)( + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) } else { - eips.systemJ.J6(approach.paradigm)(j5_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.systemJ.J6(approach.paradigm)(j5_eip)( + generator.doubles.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods, + generator.imperative.imperativeInMethods) } val k2_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.systemK.K2.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(k1_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.strings, generator.listsInMethod, generator.equality) + generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.strings.stringsInMethods, generator.lists.listsInMethods, generator.equality.equalsInMethods) } else { eips.systemK.K2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(k1_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.strings, generator.listsInMethod, generator.equality) + generator.imperative.imperativeInMethods, generator.doubles.arithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.strings.stringsInMethods, generator.lists.listsInMethods, generator.equality.equalsInMethods) } val k2j6_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.systemJK.K2J6.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(j6_eip, k2_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.strings, generator.equality) + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.equality.equalsInMethods) } else { eips.systemJK.K2J6.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(j6_eip, k2_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.strings, generator.equality) + generator.imperative.imperativeInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.equality.equalsInMethods) } val j7_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.systemJK.J7.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(k2j6_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.strings, generator.equality) + generator.functionalControl.functionalControlInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.equality.equalsInMethods) } else { eips.systemJK.J7.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(k2j6_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.strings, generator.equality) + generator.imperative.imperativeInMethods, + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.equality.equalsInMethods) } val j8_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.systemJK.J8funct(approach.paradigm)(j7_eip)(generator.functionalControl, generator.doubles) + eips.systemJK.J8funct(approach.paradigm)(j7_eip)(generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods) } else { - eips.systemJK.J8(approach.paradigm)(j7_eip)(generator.doubles, generator.realDoubles, generator.imperative) + eips.systemJK.J8(approach.paradigm)(j7_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.imperative.imperativeInMethods) } val w1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.W1(approach.paradigm)(m1_eip)(generator.doubles, generator.realDoubles, generator.strings) + eips.W1(approach.paradigm)(m1_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.strings.stringsInMethods) val m3w1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.M3W1.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip, w1_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.equality, generator.strings) + generator.doubles.arithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } else { eips.M3W1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip, w1_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.equality, generator.strings) + generator.doubles.arithmeticInMethods, generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } val q1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.Q1(approach.paradigm)(m3w1_eip)(generator.ints, generator.realDoubles, generator.treesInMethod, generator.strings) + eips.Q1(approach.paradigm)(m3w1_eip)( + generator.ints.arithmeticInMethods, + generator.realDoubles.realArithmeticInMethods, + treesInMethod, generator.strings.stringsInMethods) val c2_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.C2.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(q1_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.strings, generator.listsInMethod, generator.equality) + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.lists.listsInMethods, + generator.equality.equalsInMethods) } else { eips.C2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(q1_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.strings, generator.listsInMethod, generator.equality) + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.strings.stringsInMethods, + generator.lists.listsInMethods, + generator.equality.equalsInMethods) } val v1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.V1.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(c2_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.equality, generator.strings) + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) } else { eips.V1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(c2_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.equality, generator.strings) + generator.doubles.arithmeticInMethods, + generator.booleans.booleansInMethodsInMethods, + generator.equality.equalsInMethods, + generator.strings.stringsInMethods) } val x1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - systemX.X1funct(approach.paradigm)(m0_eip)(generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) + eips.systemX.X1funct(approach.paradigm)(m0_eip)(generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } else { - systemX.X1(approach.paradigm)(m0_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.systemX.X1(approach.paradigm)(m0_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods, generator.imperative.imperativeInMethods) } val x2_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - systemX.X2(approach.paradigm)(x1_eip)(generator.doubles, generator.strings) + eips.systemX.X2(approach.paradigm)(x1_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val x3_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - systemX.X3(approach.paradigm)(x1_eip)(generator.doubles, generator.strings) + eips.systemX.X3(approach.paradigm)(x1_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val x2x3_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - systemX.X2X3(approach.paradigm)(x2_eip, x3_eip) + eips.systemX.X2X3(approach.paradigm)(x2_eip, x3_eip) val x4_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - systemX.X4(approach.paradigm)(x2x3_eip)(generator.doubles, generator.strings) + eips.systemX.X4(approach.paradigm)(x2x3_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val m2_abs_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.M2_ABS.functional[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m2_eip)( - generator.functionalControl, generator.doubles, generator.strings) + generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) } else { eips.M2_ABS.imperative[approach.paradigm.type,ApproachImplementationProvider.WithParadigm](approach.paradigm)(m2_eip)( - generator.imperative, generator.doubles, generator.strings) + generator.imperative.imperativeInMethods, generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) } val m3i1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.M3I1.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip, i1_eip)( - generator.functionalControl, generator.booleans, generator.equality, generator.strings) + generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } else { eips.M3I1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(m3_eip, i1_eip)( - generator.imperative, generator.booleans, generator.equality, generator.strings) + generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } val n1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.N1funct(approach.paradigm)(m3_eip)(generator.functional, generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) + eips.N1funct(approach.paradigm)(m3_eip)(generator.functional, generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } else { - eips.N1(approach.paradigm)(m3_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.N1(approach.paradigm)(m3_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods, generator.imperative.imperativeInMethods) } val i2m3i1n1_eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = if (choice == "functional") { eips.I2M3I1N1.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(i2_eip, m3i1_eip, n1_eip)( - generator.booleans, generator.equality, generator.strings) + generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } else { eips.I2M3I1N1.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(i2_eip, m3i1_eip, n1_eip)( - generator.booleans, generator.equality, generator.strings) + generator.booleans.booleansInMethodsInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } val d1_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.systemD.D1funct(approach.paradigm)(m1_eip)(generator.functionalControl, generator.doubles, generator.realDoubles, generator.equality, generator.strings) + eips.systemD.D1funct(approach.paradigm)(m1_eip)(generator.functionalControl.functionalControlInMethods, generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods) } else { - eips.systemD.D1(approach.paradigm)(m1_eip)(generator.doubles, generator.realDoubles, generator.equality, generator.strings, generator.imperative) + eips.systemD.D1(approach.paradigm)(m1_eip)(generator.doubles.arithmeticInMethods, generator.realDoubles.realArithmeticInMethods, generator.equality.equalsInMethods, generator.strings.stringsInMethods, generator.imperative.imperativeInMethods) } val d2_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemD.D2(approach.paradigm)(m1_eip)(generator.doubles, generator.strings) + eips.systemD.D2(approach.paradigm)(m1_eip)(generator.doubles.arithmeticInMethods) val d1d2_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = if (choice == "functional") { - eips.systemD.D1D2.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(d1_eip, d2_eip)( - generator.functionalControl, generator.doubles, generator.booleans, generator.equality) + eips.systemD.D1D2.functional[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(d1_eip, d2_eip) } else { - eips.systemD.D1D2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(d1_eip, d2_eip)( - generator.imperative, generator.doubles, generator.booleans, generator.equality) + eips.systemD.D1D2.imperative[approach.paradigm.type, ApproachImplementationProvider.WithParadigm](approach.paradigm)(d1_eip, d2_eip) } val d3_eip: EvolutionImplementationProvider[WithParadigm[approach.paradigm.type]] = - eips.systemD.D3(approach.paradigm)(d1d2_eip)(generator.doubles, generator.strings) + eips.systemD.D3(approach.paradigm)(d1d2_eip)(generator.doubles.arithmeticInMethods, generator.strings.stringsInMethods) val eip: EvolutionImplementationProvider[ApproachImplementationProvider.WithParadigm[approach.paradigm.type]] = select match { @@ -500,7 +626,7 @@ class Main(choice:String, select:String) { _ <- approach.implement(evolution.getModel, eip) _ <- approach.implement( evolution.allTests, - TestImplementationProvider.defaultAssertionBasedTests(approach.paradigm)(generator.assertionsInMethod, generator.equality, generator.booleans, generator.strings) + TestImplementationProvider.defaultAssertionBasedTests(approach.paradigm)(generator.assertions.assertionsInMethods, generator.equality.equalsInMethods, generator.booleans.booleansInMethodsInMethods, generator.strings.stringsInMethods) ) } yield () } @@ -510,14 +636,6 @@ class Main(choice:String, select:String) { val persistable = FileWithPathPersistable[FileWithPath] - def gitTransaction: Option[BranchTransaction] = - transaction[Option[BranchTransaction]](Option.empty, (transaction, evolutionName, files) => { - val nextTransaction = - transaction.map(_.fork(evolutionName).deleteAllFiles) - .getOrElse(BranchTransaction.empty(evolutionName)) - Some(nextTransaction.persist(files())(persistable).commit("Adding next evolution")) - }) - def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { transaction[IO[Unit]](IO.unit, (transaction, evolutionName, files) => IO { print("Computing Files...") @@ -534,15 +652,6 @@ class Main(choice:String, select:String) { }) } - def runGit(args: List[String]): IO[ExitCode] = { - val name = evolutions.head.getModel.base.name - for { - _ <- IO { System.out.println(s"Use: git clone http://127.0.0.1:8081/$name ${evolutions.last.getModel.name}") } - exitCode <- new GitService(gitTransaction.toSeq, name).run(args) - //exitCode <- new GitService(transaction.toSeq, name).runProcess(Seq(s"sbt", "test")) - } yield exitCode - } - def runDirectToDisc(targetDirectory: Path): IO[ExitCode] = { for { _ <- directToDiskTransaction(targetDirectory) @@ -550,11 +659,55 @@ class Main(choice:String, select:String) { } } -object GitMain extends IOApp { - def run(args: List[String]): IO[ExitCode] = { - val approach = if (args.isEmpty) "trivially" else args.head - val selection = if (args.isEmpty || args.tail.isEmpty) "A3" else args.tail.head - new Main(approach, selection).runGit(args) +trait Subselection extends IOApp { + def approaches(args: List[String]): Seq[String] + val evolutions: Seq[String] + def target(args: List[String]): String + + override def run(args: List[String]): IO[ExitCode] = { + val target = this.target(args) + val results = approaches(args).foldLeft(IO.unit)((results, approach) => { + val printApproach = IO { + println("Generating " + approach + "...") + } + evolutions.foldLeft(results)((results, selection) => { + val targetDirectory = Paths.get("target", target, approach, selection) + val program: IO[Unit] = { + for { + _ <- IO { + println(" " + selection) + } + _ <- results + _ <- IO { + print("Initializing Generator...") + } + main <- IO { + new Main(approach, selection) + } + + _ <- IO { + println("[OK]") + } + _ <- main.runDirectToDisc(targetDirectory) + } yield () + } + for { + _ <- printApproach + _ <- program + } yield () + + // execute above as a stand-alone program + + // TBD: Would be nice to launch 'sbt' in each of these generated directories + }) + }) + + for { + _ <- results + _ <- IO { + print("DONE") + } + } yield ExitCode.Success } } @@ -563,383 +716,200 @@ object DirectToDiskMain extends IOApp { def run(args: List[String]): IO[ExitCode] = { // "M9", "J8", "A3", "O1OA", "OD3", "OO3", "V1", "D3", "I2M3I1N1", "O2" - val approach = if (args.isEmpty) "functional" else args.head - if (approach == "exit") { sys.exit(0) } - val selection = if (args.isEmpty || args.tail.isEmpty) "M2_ABS" else args.tail.head + val approach = if (args.isEmpty) "visitor" else args.head // {coco, O1OA} fails + if (approach == "exit") { + sys.exit(0) + } + val selection = if (args.isEmpty || args.tail.isEmpty) "M9" else args.tail.head println("Generating " + approach + " for " + selection) val main = new Main(approach, selection) for { - _ <- IO { print("Initializing Generator...") } - main <- IO { main } - - _ <- IO { println("[OK]") } + _ <- IO { + print("Initializing Generator...") + } + main <- IO { + main + } + _ <- IO { + println("[OK]") + } result <- main.runDirectToDisc(targetDirectory) - _ <- IO { println(s"DONE, in $targetDirectory you can now run: sbt scalafmt Test/scalafmt test") } - _ <- IO { println(s"You can generate code coverage in $targetDirectory with: sbt coverageReport")} } yield result } } +/** + * Generate ALL CODE. + */ object GenerateAll extends IOApp { - def run(args: List[String]): IO[ExitCode] = { - GenerateAllMain.run(List.empty) - GenerateAllExtended.run(List.empty) - GenerateAllThirdAlternate.run(List.empty) - GenerateAllD1D2.run(List.empty) - GenerateAllMerging.run(List.empty) - GenerateAllJ.run(List.empty) - } + def run(args: List[String]): IO[ExitCode] = for { + _ <- GenerateAllMain.run(List.empty) + _ <- GenerateAllExtended.run(List.empty) + _ <- GenerateAllThirdAlternate.run(List.empty) + _ <- GenerateAllD1D2.run(List.empty) + _ <- GenerateAllMerging.run(List.empty) + r <- GenerateAllJ.run(List.empty) + } yield r } /** - * Generate ALL CODE. - */ + * Generate ALL CODE just for one approach (as identified) + */ object GenerateAllForOneApproach extends IOApp { def run(args: List[String]): IO[ExitCode] = { val approach = if (args.isEmpty) { - List("graphviz") + List("coco") } else { args } - GenerateAllMain.run(approach) - GenerateAllExtended.run(approach) - GenerateAllThirdAlternate.run(approach) - GenerateAllD1D2.run(approach) - GenerateAllMerging.run(approach) - GenerateAllJ.run(approach) + for { + _ <- GenerateAllMain.run(approach) + _ <- GenerateAllExtended.run(approach) + _ <- GenerateAllThirdAlternate.run(approach) + _ <- GenerateAllD1D2.run(approach) + _ <- GenerateAllMerging.run(approach) + r <- GenerateAllJ.run(approach) + } yield r } } -object GenerateAllMain extends IOApp { - def run(args: List[String]): IO[ExitCode] = { +object QuickValidation extends Subselection { - val approaches = if (args.isEmpty) { - Seq("oo","visitor","extensibleVisitor","interpreter","coco","trivially","algebra") - } else { - args - } - val target = "ep-scala" - val evolutions = Seq("M0","M1","M2","M3","M4","M5","M6","M7","M7I2","M8","M9","I1","A1","A1M3","A1M3I2","A3","I2", - "O1","O2","OA","O1OA","OD1","OD2","OD3","OO1","OO2","OO3") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print(s"DONE, in your target directory you can now run: sbt scalafmt Test/scalafmt test") } - } yield ExitCode.Success - - } -} - -object QuickValidation extends IOApp { // note that visitorSideEffect and dispatch are omitted from this validation. VISITORSIDEEFFECT has a problem // with the test cases in that the methods become too long for the JavaVM and attempts to subdivide them fail // because visitorSideEffect needs to create visitor objects, and arbitrarily splitting test cases means that // they are not properly scoped and so the code fails to compile. DISPATCH is omitted because the inBetween // does not yet have exceptions. - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("trivially", "oo", "visitor", "extensibleVisitor", "interpreter", "coco", "algebra") - } else { - args - } - - val target = "ep-scala-quick" - - // latest in all system families - val evolutions = Seq("M9", "J8", "A3", "O1OA", "OD3", "OO3", "V1", "D3", "I2M3I1N1", "O2") - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("trivially", "oo", "visitor", "extensibleVisitor", "interpreter", "coco", "algebra") + } else { + args + } - // execute above as a stand-alone program - program.unsafeRunSync() + def target(args: List[String]): String = "ep-scala-quick" - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) + // latest in all system families + val evolutions = Seq("M9", "J8", "A3", "O1OA", "OD3", "OO3", "V1", "D3", "I2M3I1N1", "O2") - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success - - } } +object GenerateAllMain extends Subselection { -object GenerateAllExtended extends IOApp { - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-scala-extended" - } else { - args.head - } - val evolutions = Seq("M0","M1","M2","M3", "W1", "M3W1", "Q1", "C2", "V1") + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala" + } else { + args.head + } + val evolutions = Seq("M0", "M1", "M2", "M3", "M4", "M5", "M6", "M7", "M7I2", "M8", "M9", "I1", "A1", "A1M3", "A1M3I2", "A3", "I2", + "O1", "O2", "OA", "O1OA", "OD1", "OD2", "OD3", "OO1", "OO2", "OO3") - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) +} - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } +object GenerateAllJ extends Subselection { - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - // execute above as a stand-alone program - program.unsafeRunSync() + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala-j" + } else { + args.head + } + val evolutions = Seq("M0", "J1", "J2", "J3", "K1", "K2", "J4", "J5", "J6", "K2J6", "J7", "J8") - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) +} - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success +object GenerateAllD1D2 extends Subselection { + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala-d1d2" + } else { + args.head + } + val evolutions = Seq("M0", "M1", "D1", "D2", "D1D2", "D3") } -object GenerateAllThirdAlternate extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-scala-third-alternate" - } else { - args.head - } - val evolutions = Seq("M0", "X1", "X2", "X3", "X2X3", "X4") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success +object GenerateAllMerging extends Subselection { + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala-merging" + } else { + args.head + } + val evolutions = Seq("M0", "M1", "M2", "I1", "I2", "N1", "M2_ABS", "M3", "M3I1", "I2M3I1N1") } -object GenerateAllD1D2 extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-scala-d1d2" - } else { - args.head - } - val evolutions = Seq("M0", "M1", "D1", "D2", "D1D2", "D3") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) +object GenerateAllExtended extends Subselection { - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala-extended" + } else { + args.head } + val evolutions = Seq("M0", "M1", "M2", "M3", "W1", "M3W1", "Q1", "C2", "V1") } -object GenerateAllMerging extends IOApp { +object GenerateAllThirdAlternate extends Subselection { - def run(args: List[String]): IO[ExitCode] = { - - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-scala-merging" - } else { - args.head - } - val evolutions = Seq("M0","M1","M2","I1","I2","N1","M2_ABS","M3","M3I1","I2M3I1N1") - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala-third-alternate" + } else { + args.head + } + val evolutions = Seq("M0", "X1", "X2", "X3", "X2X3", "X4") } -object GenerateAllJ extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - // visitor side effect is eliminated. When there are a large number of test cases, the internal - // code separates arbitrarily these test cases into 500-line chunks. Unfortunately for the - // visitorSideEffect, this causes problems because local variables are used for the visitors and - // they are unreachable when split across multiple methods. - // - // "dispatch" is not yet available for Scala - val approaches = if (args.isEmpty) { - Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - } else { - args - } - val target = if (args.isEmpty) { - "ep-scala-j" - } else { - args.head - } - val evolutions = Seq("M0","J1","J2","J3","K1","K2","J4","J5","J6","K2J6","J7","J8") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", target, approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new Main(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) +object GenerateShapes extends Subselection { - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success + def approaches(args: List[String]): Seq[String] = if (args.isEmpty) { + Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") + } else { + args + } + def target(args: List[String]): String = if (args.isEmpty) { + "ep-scala-shapes" + } else { + args.head } + val evolutions = Seq("S0", "S1", "S2") } diff --git a/builder/src/main/scala/org/combinators/ep/builder/scala/paradigm/ffi/TreesAST.scala b/builder/src/main/scala/org/combinators/ep/builder/scala/paradigm/ffi/TreesAST.scala new file mode 100644 index 00000000..a9a06329 --- /dev/null +++ b/builder/src/main/scala/org/combinators/ep/builder/scala/paradigm/ffi/TreesAST.scala @@ -0,0 +1,107 @@ +package org.combinators.ep.builder.scala.paradigm.ffi + +import org.combinators.cogen.{FileWithPath, TypeRep} +import org.combinators.ep.builder.inbetween.paradigm.ffi.TreesAST as InbetweenTreesAST +import org.combinators.ep.domain.abstractions.DomainTpeRep +import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphismAST +import org.combinators.ep.language.scala.ast.{BaseAST, FinalBaseAST} + +import java.nio.file.Paths + +trait TreesAST extends InbetweenTreesAST { self: ParametricPolymorphismAST & BaseAST => + object scalaTreesOps { + object treesOpsOverride { + trait FinalTypes extends treesOps.FinalTypes { + type Tree <: treesOpsOverride.Tree + type Leaf <: treesOpsOverride.Leaf + type Node <: treesOpsOverride.Node + } + + + + trait Tree extends treesOps.Tree with scalaBase.ooOverrides.ClassReferenceType { + def qualifiedClassName: Seq[any.Name] = qualifiedClassNameTree + } + + trait Leaf extends treesOps.Leaf with scalaBase.ooOverrides.ClassReferenceType { + def qualifiedClassName: Seq[any.Name] = qualifiedClassNameLeaf + } + + trait Node extends treesOps.Node with scalaBase.ooOverrides.ClassReferenceType { + def qualifiedClassName: Seq[any.Name] = qualifiedClassNameNode + } + + trait Factory extends treesOps.Factory {} + } + + def treeReificationExtensions(tpe: TypeRep)(value: tpe.HostType): Option[String] = { + tpe match { + case t: DomainTpeRep.Tree.type => + value match { + case org.combinators.ep.domain.tree.Node(id, values) => Some(s"org.combinators.ep.util.Node($id, ${values.map(v => scalaBaseFactory.reifiedScalaValue(DomainTpeRep.Tree, v).toScala).mkString(", ")})") + case org.combinators.ep.domain.tree.Leaf(r) => Some(s"org.combinators.ep.util.Leaf(${scalaBaseFactory.reifiedScalaValue(r.tpe, r.inst).toScala})") + } + case _ => None + } + } + + + val qualifiedClassNameTree: Seq[any.Name] = Seq("org", "combinators", "ep", "util", "Tree").map(n => scalaBaseFactory.name(n, n)) + val qualifiedClassNameLeaf: Seq[any.Name] = Seq("org", "combinators", "ep", "util", "Leaf").map(n => scalaBaseFactory.name(n, n)) + val qualifiedClassNameNode: Seq[any.Name] = Seq("org", "combinators", "ep", "util", "Node").map(n => scalaBaseFactory.name(n, n)) + def treePrefixExcludes: Set[Seq[any.Name]] = + Set(qualifiedClassNameTree, qualifiedClassNameNode, qualifiedClassNameLeaf) + + def treeLibrary: Seq[FileWithPath] = { + Seq(FileWithPath( + getClass.getResourceAsStream("/scala-code/org/combinators/ep/util/Trees.scala").readAllBytes(), + Paths.get("src", "main", "scala", "org", "combinators", "ep", "util", "Trees.scala") + )) + } + } + + override val treesOpsFinalTypes: scalaTreesOps.treesOpsOverride.FinalTypes + override val treesOpsFactory: scalaTreesOps.treesOpsOverride.Factory +} + +trait FinalTreesAST extends TreesAST { self: FinalBaseAST => + object treesFinalTypes { + trait FinalTrees extends scalaTreesOps.treesOpsOverride.FinalTypes { + type Tree = scalaTreesOps.treesOpsOverride.Tree + type Leaf = scalaTreesOps.treesOpsOverride.Leaf + type Node = scalaTreesOps.treesOpsOverride.Node + } + } + + object finalTreesFactoryTypes { + trait FinalTreesFactory extends scalaTreesOps.treesOpsOverride.Factory { + def tree(): treesOps.Tree = { + case class Tree() extends scalaTreesOps.treesOpsOverride.Tree { + override def getSelfTree: treesOpsFinalTypes.Tree = this + def getSelfClassReferenceType: scalaBase.ooOverrides.ClassReferenceType = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + Tree() + } + def node(): treesOps.Node = { + case class Node() extends scalaTreesOps.treesOpsOverride.Node { + override def getSelfNode: treesOpsFinalTypes.Node = this + def getSelfClassReferenceType: scalaBase.ooOverrides.ClassReferenceType = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + Node() + } + def leaf(): treesOps.Leaf = { + case class Leaf() extends scalaTreesOps.treesOpsOverride.Leaf { + override def getSelfLeaf: treesOpsFinalTypes.Leaf = this + def getSelfClassReferenceType: scalaBase.ooOverrides.ClassReferenceType = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + Leaf() + } + } + } + + override val treesOpsFinalTypes: treesFinalTypes.FinalTrees = new treesFinalTypes.FinalTrees {} + override val treesOpsFactory: finalTreesFactoryTypes.FinalTreesFactory = new finalTreesFactoryTypes.FinalTreesFactory {} +} \ No newline at end of file diff --git a/core/src/main/scala/org/combinators/ep/generator/AbstractSyntax.scala b/cogen/src/main/scala/org/combinators/cogen/AbstractSyntax.scala similarity index 91% rename from core/src/main/scala/org/combinators/ep/generator/AbstractSyntax.scala rename to cogen/src/main/scala/org/combinators/cogen/AbstractSyntax.scala index 438ed7f9..59a6eebe 100644 --- a/core/src/main/scala/org/combinators/ep/generator/AbstractSyntax.scala +++ b/cogen/src/main/scala/org/combinators/cogen/AbstractSyntax.scala @@ -1,4 +1,4 @@ -package org.combinators.ep.generator /*DI:LI:AI*/ +package org.combinators.cogen /** Provides type definitions for abstract syntax tree components. */ trait AbstractSyntax { diff --git a/core/src/main/scala/org/combinators/ep/generator/Command.scala b/cogen/src/main/scala/org/combinators/cogen/Command.scala similarity index 63% rename from core/src/main/scala/org/combinators/ep/generator/Command.scala rename to cogen/src/main/scala/org/combinators/cogen/Command.scala index 8ba8afd2..9548d949 100644 --- a/core/src/main/scala/org/combinators/ep/generator/Command.scala +++ b/cogen/src/main/scala/org/combinators/cogen/Command.scala @@ -1,7 +1,7 @@ -package org.combinators.ep.generator /*DI:LI:AI*/ +package org.combinators.cogen -import cats.data.State import cats._ +import cats.data.State import cats.free.Free import cats.free.Free.liftF @@ -19,34 +19,37 @@ trait Command { def interpret[Context, Self >: this.type <: Command.WithResult[Result]](implicit interp: Understands[Context, Self]): Command.Generator[Context, Result] = { val self: Self = this - liftF[Command.Performable[Context, *], Result](new Command.Performable[Context, Result] { - type Cmd = Self - val cmd = self - val interpreter = interp - }) + liftF[Command.Performable[Context, _], Result](Command.Performable[Context, Result, Self](self, interp)) } } object Command { type WithResult[R] = Command { type Result = R } - type Generator[C, A] = Free[Performable[C, *], A] + type Generator[C, A] = Free[Performable[C, _], A] sealed trait Performable[Context, R] { type Cmd <: Command.WithResult[R] val cmd: Cmd val interpreter: Understands[Context, Cmd] } + object Performable { + type Aux[Context, R, C <: Command.WithResult[R]] = Performable[Context, R] { type Cmd = C } + def apply[Context, R, C <: Command.WithResult[R]](cmd: C, interpreter: Understands[Context, C]): Aux[Context, R, C] = { + case class P(cmd: C, interpreter: Understands[Context, C]) extends Performable[Context, R] { type Cmd = C } + P(cmd, interpreter) + } + } def runGenerator[Context, Result](gen: Generator[Context, Result], inContext: Context): (Context, Result) = { - val compiler: Performable[Context, *] ~> State[Context, *] = new (Performable[Context, *] ~> State[Context, *]) { + val compiler: Performable[Context, _] ~> State[Context, _] = new (Performable[Context, _] ~> State[Context, _]) { def apply[A](fa: Performable[Context, A]): State[Context, A] = State[Context, A](ctxt => fa.interpreter.perform(ctxt, fa.cmd)) } gen.foldMap(compiler).run(inContext).value } - implicit def monadInstance[C]: Monad[Generator[C, *]] = - cats.free.Free.catsFreeMonadForFree[Performable[C, *]] + implicit def monadInstance[C]: Monad[Generator[C, _]] = + cats.free.Free.catsFreeMonadForFree[Performable[C, _]] def lift[Context, T](value: T): Command.Generator[Context, T] = monadInstance.pure(value) def skip[Context]: Generator[Context, Unit] = lift(()) diff --git a/core/src/main/scala/org/combinators/ep/generator/FileWithPath.scala b/cogen/src/main/scala/org/combinators/cogen/FileWithPath.scala similarity index 96% rename from core/src/main/scala/org/combinators/ep/generator/FileWithPath.scala rename to cogen/src/main/scala/org/combinators/cogen/FileWithPath.scala index 98816864..7ba1609c 100644 --- a/core/src/main/scala/org/combinators/ep/generator/FileWithPath.scala +++ b/cogen/src/main/scala/org/combinators/cogen/FileWithPath.scala @@ -1,9 +1,9 @@ -package org.combinators.ep.generator /*DI:LI:AI*/ - -import java.nio.file.Path +package org.combinators.cogen import org.combinators.templating.persistable.Persistable +import java.nio.file.Path + /** * Contents of file to be stored at `persistTo`. * diff --git a/core/src/main/scala/org/combinators/ep/generator/FreshNameProvider.scala b/cogen/src/main/scala/org/combinators/cogen/FreshNameProvider.scala similarity index 95% rename from core/src/main/scala/org/combinators/ep/generator/FreshNameProvider.scala rename to cogen/src/main/scala/org/combinators/cogen/FreshNameProvider.scala index d3210f16..2ff96e3d 100644 --- a/core/src/main/scala/org/combinators/ep/generator/FreshNameProvider.scala +++ b/cogen/src/main/scala/org/combinators/cogen/FreshNameProvider.scala @@ -1,4 +1,4 @@ -package org.combinators.ep.generator /*DI:LI:AI*/ +package org.combinators.cogen case class FreshNameProvider[Name]( pushName: (Name, Int) => Name, diff --git a/cogen/src/main/scala/org/combinators/cogen/InstanceRep.scala b/cogen/src/main/scala/org/combinators/cogen/InstanceRep.scala new file mode 100644 index 00000000..078f94c0 --- /dev/null +++ b/cogen/src/main/scala/org/combinators/cogen/InstanceRep.scala @@ -0,0 +1,43 @@ +package org.combinators.cogen + +/** A host language (Scala) instance, which can be represented inside of a domain. + * + * In type theory this is encoded as a dependent sum, Sigma, where there exists a type and an instance for that type. + * Check [[https://partialflow.wordpress.com/2017/07/26/dependent-types-type-level-programming/ this introduction]] + * on dependent types in Scala. + * + * The type of the instance is captured by 'tpe' + * + * @see The companion model [[org.combinators.cogen.InstanceRep]] for creating new instances. + */ +sealed trait InstanceRep { + /** Provides the domain representation of the instance type. */ + val tpe: TypeRep + /** Provides the host language (Scala) instance. */ + val inst: tpe.HostType + + override def hashCode(): Int = inst.hashCode() + override def equals(obj: Any): Boolean = { + obj match { + case that: InstanceRep => + that.isInstanceOf[InstanceRep] && inst == that.inst + case _ => false + } + } +} + +/** Provides methods for wrapping host language (Scala) instances into domain representable entities. */ +object InstanceRep { + /** Type of represented instances of a given host language (Scala) type. */ + type OfHostType[T] = InstanceRep {val tpe: TypeRep.OfHostType[T]} + + /** Creates a new instance representation for the given representable host language type and an instance of it. */ + def apply(tpe: TypeRep)(inst: tpe.HostType): InstanceRep = { + val tpeArg: tpe.type = tpe + val instArg: tpeArg.HostType = inst + case class IR(override val tpe: tpeArg.type)( + override val inst: tpeArg.HostType + ) extends InstanceRep + IR(tpeArg)(instArg) + } +} \ No newline at end of file diff --git a/cogen/src/main/scala/org/combinators/cogen/NameProvider.scala b/cogen/src/main/scala/org/combinators/cogen/NameProvider.scala new file mode 100644 index 00000000..63713892 --- /dev/null +++ b/cogen/src/main/scala/org/combinators/cogen/NameProvider.scala @@ -0,0 +1,13 @@ +package org.combinators.cogen + +/** Provides mangled names for domain entities. */ +abstract class NameProvider[Name] { + /** Mangles `name` according to language specific rules, with set . */ + def mangle(name: String): Name + + /** Adds a prefix to the given name. The new name will be mangled if necessary. */ + def addPrefix(prefix: String, name: Name): Name + + /** Adds a suffix to the given name. The new name will be mangled if necessary. */ + def addSuffix(name: Name, suffix: String): Name +} diff --git a/cogen/src/main/scala/org/combinators/cogen/Tag.scala b/cogen/src/main/scala/org/combinators/cogen/Tag.scala new file mode 100644 index 00000000..b4675bbc --- /dev/null +++ b/cogen/src/main/scala/org/combinators/cogen/Tag.scala @@ -0,0 +1,4 @@ +package org.combinators.cogen + +/** Used to mark special operations (needed for isOp logic) and possible useful in other ways. */ +trait Tag {} diff --git a/cogen/src/main/scala/org/combinators/cogen/TestCase.scala b/cogen/src/main/scala/org/combinators/cogen/TestCase.scala new file mode 100644 index 00000000..bcc8f0ab --- /dev/null +++ b/cogen/src/main/scala/org/combinators/cogen/TestCase.scala @@ -0,0 +1,6 @@ +package org.combinators.cogen + +/** Marks any inheriting object as a model of a software test case. */ +trait TestCase { + val tags: Seq[Tag] = Seq.empty +} diff --git a/cogen/src/main/scala/org/combinators/cogen/TypeRep.scala b/cogen/src/main/scala/org/combinators/cogen/TypeRep.scala new file mode 100644 index 00000000..5e172ee7 --- /dev/null +++ b/cogen/src/main/scala/org/combinators/cogen/TypeRep.scala @@ -0,0 +1,56 @@ +package org.combinators.cogen + +/** + * Represents a host language (Scala) type within the domain. + * @see [[org.combinators.cogen.TypeRep]] for helpers to construct representations. + */ +trait TypeRep { + /** The type to represent. */ + type HostType +} + +/** Provides helpers to construct domain representations of host language types. */ +object TypeRep { + /** Representation of the host type `T`. */ + type OfHostType[T] = TypeRep {type HostType = T} + + /** Represents the Scala type `Unit`. */ + case object Unit extends TypeRep { + type HostType = scala.Unit + } + + /** Represents the Scala type `String` */ + case object String extends TypeRep { + type HostType = java.lang.String + } + + /** Represents the Scala type `Int`. */ + case object Int extends TypeRep { + type HostType = scala.Int + } + + /** Represents the Scala type `Double`. */ + case object Double extends TypeRep { + type HostType = scala.Double + } + + /** Represents the Scala type `Boolean`. */ + case object Boolean extends TypeRep { + type HostType = scala.Boolean + } + + /** Represents the type `Seq[A]` */ + case class Sequence[T](elemTpe: TypeRep.OfHostType[T]) extends TypeRep { + type HostType = Seq[T] + } + + /** Represents the type `Array[T]` */ + case class Array[T](elemTpe: TypeRep.OfHostType[T]) extends TypeRep { + type HostType = Array[T] + } + + /** Represents the type A => B */ + case class Arrow[A, B](src: TypeRep.OfHostType[A], tgt: TypeRep.OfHostType[B]) extends TypeRep { + type HostType = A => B + } +} \ No newline at end of file diff --git a/core/src/main/scala/org/combinators/ep/generator/Understands.scala b/cogen/src/main/scala/org/combinators/cogen/Understands.scala similarity index 90% rename from core/src/main/scala/org/combinators/ep/generator/Understands.scala rename to cogen/src/main/scala/org/combinators/cogen/Understands.scala index a572e081..a219b62d 100644 --- a/core/src/main/scala/org/combinators/ep/generator/Understands.scala +++ b/cogen/src/main/scala/org/combinators/cogen/Understands.scala @@ -1,4 +1,4 @@ -package org.combinators.ep.generator /*DI:LI:AI*/ +package org.combinators.cogen @scala.annotation.implicitNotFound(msg = "Context ${Context} does not understand ${Cmd}") trait Understands[Context, Cmd <: Command] { diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/AnyParadigm.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/AnyParadigm.scala similarity index 93% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/AnyParadigm.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/AnyParadigm.scala index 8b5f7c9d..4603d588 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/AnyParadigm.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/AnyParadigm.scala @@ -1,9 +1,8 @@ -package org.combinators.ep.generator.paradigm /*DI:LI:AI*/ +package org.combinators.cogen.paradigm -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.{AbstractSyntax, Command, FileWithPath, Understands} +import org.combinators.cogen.{AbstractSyntax, Command, FileWithPath, Understands, TypeRep} import Command._ -import cats.implicits._ +import cats.implicits._ // needed for .sequence /** Adds a compilation unit with sequence of names for hierarchy, if needed */ case class AddCompilationUnit[Name, CompilationUnitContext](unit: Generator[CompilationUnitContext, Unit], name: Seq[Name]) @@ -98,6 +97,11 @@ case class OutputToConsole[Expression](expr: Expression) extends Command { type Result = Unit } +/** Ability to add custom files (e.g. for included libs or resources) to projects. */ +case class AddCustomFile(file: FileWithPath) extends Command { + type Result = Unit +} + trait AnyParadigm { val syntax: AbstractSyntax @@ -129,8 +133,14 @@ trait AnyParadigm { AnyParadigm.capability(AddCompilationUnit(unit, qualifiedName)) implicit val canAddTypeLookupForMethodsInProject: Understands[ProjectContext, AddTypeLookup[MethodBodyContext, Type]] - def addTypeLookupForMethods(tpe: TypeRep, lookup: Generator[MethodBodyContext, Type]): Generator[ProjectContext, Unit] = + def addTypeLookupForMethods(tpe: TypeRep, lookup: Generator[MethodBodyContext, Type]): Generator[ProjectContext, Unit] = { AnyParadigm.capability(AddTypeLookup[MethodBodyContext, Type](tpe, lookup)) + } + + implicit val canAddCustomFile: Understands[ProjectContext, AddCustomFile] + def addCustomFile(file: FileWithPath): Generator[ProjectContext, Unit] = { + AnyParadigm.capability(AddCustomFile(file)) + } } val projectCapabilities: ProjectCapabilities diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/Functional.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/Functional.scala similarity index 95% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/Functional.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/Functional.scala index 9c5dcafc..282db79d 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/Functional.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/Functional.scala @@ -1,8 +1,7 @@ -package org.combinators.ep.generator.paradigm /*DI:LI:AI*/ +package org.combinators.cogen.paradigm -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.{TypeRep, Command, Understands} +import Command.Generator case class AddType[Name, TypeContext](name: Name, tpeGen: Generator[TypeContext, Unit]) extends Command { type Result = Unit diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/Generics.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/Generics.scala similarity index 93% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/Generics.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/Generics.scala index 3ec6549c..17aa46b4 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/Generics.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/Generics.scala @@ -1,7 +1,7 @@ -package org.combinators.ep.generator.paradigm /*DI:LI:AI*/ +package org.combinators.cogen.paradigm -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class AddLowerBound[Type](bound: Type) extends Command { type Result = Unit @@ -16,7 +16,7 @@ case class GetCurrentTypeParameter[Type]() extends Command { } trait Generics { - val base: org.combinators.ep.generator.paradigm.AnyParadigm + val base: AnyParadigm val ooParadigm: ObjectOriented.WithBase[base.type] val ppolyParadigm: ParametricPolymorphism.WithBase[base.type] diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ObjectOriented.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ObjectOriented.scala similarity index 98% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ObjectOriented.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ObjectOriented.scala index 25b2d898..fad25c8a 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ObjectOriented.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ObjectOriented.scala @@ -1,8 +1,7 @@ -package org.combinators.ep.generator.paradigm /*DI:LI:AI*/ +package org.combinators.cogen.paradigm -import org.combinators.ep.generator.{AbstractSyntax, Command, Understands} +import org.combinators.cogen.{Command, Understands, TypeRep} import Command.Generator -import org.combinators.ep.domain.abstractions.{DataType, TypeRep} case class AddClass[ClassContext, Name]( name: Name, @@ -282,7 +281,6 @@ trait ObjectOriented { implicit val canInstantiateObjectInMethod: Understands[MethodBodyContext, InstantiateObject[Type, Expression, ClassContext]] def instantiateObject(tpe: Type, constructorArguments: Seq[Expression], body:Option[Generator[ClassContext,Unit]] = None): Generator[MethodBodyContext, Expression] = AnyParadigm.capability(InstantiateObject(tpe, constructorArguments, body)) - // TODO: body is never used implicit val canGetMemberInMethod: Understands[MethodBodyContext, GetMember[Expression, Name]] def getMember(instance: Expression, member: Name): Generator[MethodBodyContext, Expression] = @@ -334,7 +332,7 @@ trait ObjectOriented { def addClassToProject(classGen: Generator[ClassContext, Unit], qualifiedName: Name* ): Generator[ProjectContext, Unit] = { import compilationUnitCapabilities._ import base.projectCapabilities._ - addCompilationUnit(AddClass(qualifiedName.last, classGen).interpret, qualifiedName: _*) + addCompilationUnit(AddClass(qualifiedName.last, classGen).interpret, qualifiedName*) } implicit val canAddTypeLookupForClassesInProject: Understands[ProjectContext, AddTypeLookup[ClassContext, Type]] diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ParametricPolymorphism.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphism.scala similarity index 87% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ParametricPolymorphism.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphism.scala index 6e5ae04c..127d8ac9 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ParametricPolymorphism.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphism.scala @@ -1,7 +1,7 @@ -package org.combinators.ep.generator.paradigm /*DI:LI:AI*/ +package org.combinators.cogen.paradigm -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class AddTypeParameter[Name, TypeParameterContext]( name: Name, @@ -15,7 +15,7 @@ case class GetTypeArguments[Type]() extends Command { } trait ParametricPolymorphism { - val base: org.combinators.ep.generator.paradigm.AnyParadigm + val base: AnyParadigm import base._ import syntax._ diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ParametricPolymorphismInADTContexts.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphismInADTContexts.scala similarity index 76% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ParametricPolymorphismInADTContexts.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphismInADTContexts.scala index 85e8bb2d..757e0618 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ParametricPolymorphismInADTContexts.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphismInADTContexts.scala @@ -1,10 +1,10 @@ -package org.combinators.ep.generator.paradigm +package org.combinators.cogen.paradigm -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.Understands trait ParametricPolymorphismInADTContexts { - val base: org.combinators.ep.generator.paradigm.AnyParadigm + val base: AnyParadigm val functional: Functional.WithBase[base.type] import base._ diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/control/Functional.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/control/Functional.scala similarity index 92% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/control/Functional.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/control/Functional.scala index 65245604..d8fd16ec 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/control/Functional.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/control/Functional.scala @@ -1,9 +1,8 @@ -package org.combinators.ep.generator.paradigm.control /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.control -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply, FreshName, IfThenElse, Reify} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply, IfThenElse, Reify} +import org.combinators.cogen.{TypeRep, Command, Understands} +import Command.Generator case class PatternMatch[MethodBodyContext, PatternContext, Expression]( onValue: Expression, diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/control/Imperative.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/control/Imperative.scala similarity index 91% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/control/Imperative.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/control/Imperative.scala index 93a9b7b5..c2e5a33d 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/control/Imperative.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/control/Imperative.scala @@ -1,11 +1,9 @@ -package org.combinators.ep.generator.paradigm.control /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.control -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{AnyParadigm, IfThenElse} +import org.combinators.cogen.{Command, Understands} +import Command.Generator -import cats.implicits._ -import cats.free.Free._ +import org.combinators.cogen.paradigm.{AnyParadigm, IfThenElse} case class DeclareVariable[Name, Type, Init, Res](name: Name, tpe: Type, initialization: Init) extends Command { type Result = Res diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/control/Lambdas.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/control/Lambdas.scala similarity index 72% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/control/Lambdas.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/control/Lambdas.scala index 8286566d..3526d8e8 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/control/Lambdas.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/control/Lambdas.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.control /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.control -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Lambda[Name, Type, Context, Expression](variables: Seq[(Name,Type)], body: Map[Name,Expression] => Generator[Context, Expression]) extends Command { type Result = Expression diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Arithmetic.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Arithmetic.scala similarity index 90% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Arithmetic.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Arithmetic.scala index 01872fb3..535ab46a 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Arithmetic.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Arithmetic.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Add[T]() case class Sub[T]() diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Arrays.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Arrays.scala similarity index 84% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Arrays.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Arrays.scala index 530a9156..5be15cf3 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Arrays.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Arrays.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply, ParametricPolymorphism} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class CreateArray[Type](elementType: Type) case class Get() diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Assertions.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Assertions.scala similarity index 87% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Assertions.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Assertions.scala index 39238547..56893694 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Assertions.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Assertions.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Assert(message: String = "") diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Booleans.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Booleans.scala similarity index 86% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Booleans.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Booleans.scala index 0b8a65dc..403e2453 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Booleans.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Booleans.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} -import org.combinators.ep.generator.{Command, Understands} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class And(shortcut: Boolean = true) case class Or(shortcut: Boolean = true) diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Console.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Console.scala similarity index 68% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Console.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Console.scala index 1f6e3136..793d5ad3 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Console.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Console.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case object Print diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Equality.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Equality.scala similarity index 71% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Equality.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Equality.scala index 4268b1b8..894c7ab8 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Equality.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Equality.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Equals[Type](inType: Type) diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Exceptions.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Exceptions.scala similarity index 69% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Exceptions.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Exceptions.scala index 88dcd94e..e50cec08 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Exceptions.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Exceptions.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Exception[Expression,Stmt](exp:Expression) extends Command { type Result = Stmt diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/FFI.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/FFI.scala similarity index 51% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/FFI.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/FFI.scala index ab72f7c4..1e24b986 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/FFI.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/FFI.scala @@ -1,7 +1,7 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.Command.Generator /** * Foreign Function Interfaces. diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Lists.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Lists.scala similarity index 86% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Lists.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Lists.scala index 75e62664..bea87fd8 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Lists.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Lists.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply, ParametricPolymorphism} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Create[Type](elementType: Type) case class Cons() diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/RealArithmetic.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/RealArithmetic.scala similarity index 89% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/RealArithmetic.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/RealArithmetic.scala index 20467977..adcc9d7f 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/RealArithmetic.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/RealArithmetic.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class Sqrt[T]() case class Pow[T]() @@ -50,7 +50,7 @@ trait RealArithmetic[Context, T] extends FFI { implicit val canPi: Understands[Context, Pi[Expression]] def pi(): Generator[Context, Expression] = - AnyParadigm.capability(Pi[Expression]) + AnyParadigm.capability(Pi[Expression]()) implicit val canAbs: Understands[Context, Apply[Abs[T], Expression, Expression]] def abs(xs: Expression): Generator[Context, Expression] = diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Strings.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Strings.scala similarity index 87% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Strings.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Strings.scala index 2d0e3b49..4ddfbec3 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Strings.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Strings.scala @@ -1,9 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply, Reify} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply, Reify} +import org.combinators.cogen.{Command, Understands, TypeRep} +import Command.Generator import scala.annotation.tailrec @@ -41,7 +40,7 @@ trait Strings[Context] extends FFI { sepExp <- Reify[String, Expression](TypeRep.String, sep).interpret endExp <- Reify[String, Expression](TypeRep.String, end).interpret inters = startExp +: make(sepExp, endExp, tl => tl, exprs) - res <- stringAppend(inters:_*) + res <- stringAppend(inters*) } yield res } diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Time.scala b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Time.scala similarity index 67% rename from core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Time.scala rename to cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Time.scala index 6f3b286f..19d529d4 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Time.scala +++ b/cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Time.scala @@ -1,8 +1,8 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.cogen.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.{Command, Understands} +import Command.Generator case class GetTime() diff --git a/core/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala b/core/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala deleted file mode 100644 index 122dd947..00000000 --- a/core/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala +++ /dev/null @@ -1,371 +0,0 @@ -package org.combinators.ep.approach.oo /*DI:LI:AD*/ - -import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.GenericModel -import org.combinators.ep.generator.Command._ -import org.combinators.ep.generator._ -import org.combinators.ep.generator.communication._ -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax._ -import org.combinators.ep.generator.paradigm._ -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Exceptions, Strings} - -/** - * Runtime Dispatch - * - * Have to decide whether to use side effects or Generics. This current implementation uses the Visitor generics - * approach, which can be adopted by different object oriented languages. - */ -trait RuntimeDispatch extends SharedOO with OperationAsClass { - val paradigm: AnyParadigm - val ooParadigm: ObjectOriented.WithBase[paradigm.type] - val names: NameProvider[paradigm.syntax.Name] - - val impParadigm: Imperative.WithBase[paradigm.MethodBodyContext,paradigm.type] - val exceptions: Exceptions.WithBase[paradigm.MethodBodyContext,paradigm.type] - val strings: Strings.WithBase[paradigm.MethodBodyContext,paradigm.type] - - import ooParadigm._ - import paradigm._ - import syntax._ - - val expParameter: String = "exp" - - /** - * Instantiates an instance of the domain object. - * - * Same implementation for OO as for visitor. - * - * new Add(new Lit(new Double(1.0)), new Lit(new Double(2.0))) - */ - def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] = { - import paradigm.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - for { - // access the constructor for the class associated with type case and invoke constructors with arguments. - rt <- findClass(names.mangle(names.conceptNameOf(tpeCase))) - _ <- resolveAndAddImport(rt) - res <- instantiateObject(rt, args) - } yield res - } - - /** - * Dispatch creates a new dispatch object and invokes operation with attributes. - * - * new Eval().eval(e.getLeft()) + new Eval().eval(e.getRight()) - * - * @param message the SendRequest - * @return - */ - def dispatch(message: SendRequest[Expression]): Generator[MethodBodyContext, Expression] = { - import ooParadigm.methodBodyCapabilities._ - import paradigm.methodBodyCapabilities._ - val op = message.request.op - for { - - // the operation is encoded in its own class, which we must find to determine the visitor type - opType <- findClass(names.mangle(names.conceptNameOf(op))) // Each class is based on Operation - _ <- resolveAndAddImport(opType) // gives resulting import statement (if needed) - - // construct the Operation object for the given type (and parameters) - dispatcher <- instantiateObject(opType, op.parameters.map(param => message.request.arguments(param))) - - // In the 'message.to' expression, invoke the 'accept' method with a visitor argument - method <- getMember(dispatcher, names.mangle(names.instanceNameOf(op))) // things which are code-generated use the '<-' handles unpacking results - rt <- toTargetLanguageType(message.request.op.returnType) - _ <- resolveAndAddImport(rt) - - // apply to method with the visitor, resulting in the expression - result <- apply(method, Seq(message.to)) // has to be Seq[] just for syntax of calling the method - } yield result - } - - /** - * - * {{{ - * public op.returnType ???(rt e); - * }}} - * @return - */ - def makeOperationSignature(paramType:Type, op:Operation): Generator[MethodBodyContext, Unit] = { - import paradigm.methodBodyCapabilities._ - for { - - // this returns mangled visitTypeParameter name and gets list of all type parameters, for which there is only one, so we get head - rt <- toTargetLanguageType(op.returnType) - _ <- resolveAndAddImport(rt) - _ <- setReturnType(rt) - - expParam <- freshName(names.mangle(expParameter)) - _ <- setParameters(Seq((expParam, paramType))) // a pair (name,type) of only one sequence - } yield () - } - - /** - * Create an operation that dispatches accordingly to all known data types to helper method. - * {{{ - * public RT op(Exp exp) { - * if (exp instanceof Lit) { - return _eval((Lit) exp); - } - - if (exp instanceof Add) { - return _eval((Add) exp); - } - - * } - * }}} - * @return - */ - def makeDispatchingOperation(model:GenericModel, op:Operation): Generator[ClassContext, Unit] = { - def ifStmt(): Generator[MethodBodyContext, Option[Expression]] = { - import ooParadigm.methodBodyCapabilities._ - import paradigm.methodBodyCapabilities._ - import impParadigm.imperativeCapabilities._ - import exceptions.exceptionCapabilities._ - - for { - _ <- forEach(model.flatten.typeCases) { tpe => - for { - tpeCase <- findClass(names.mangle(names.conceptNameOf(tpe))) - _ <- resolveAndAddImport(tpeCase) - args <- getArguments() - condExpr <- instanceOfType(tpeCase, args.head._3) - self <- selfReference() - innerFunction <- getMember(self, names.addPrefix("_", names.mangle(names.instanceNameOf(op)))) - - casted <- castObject(tpeCase, args.head._3) - result <- apply(innerFunction, Seq(casted)) - blockReturn <- returnStmt(result) - ifs <- ifThenElse(condExpr, addBlockDefinitions(Seq(blockReturn)), Seq.empty) - _ <- addBlockDefinitions(Seq(ifs)) - } yield None - } - - expr <- this.reify(InstanceRep(TypeRep.String)("Missing Subclass Case!")) - throws <- raise(expr) - _ <- addBlockDefinitions(Seq(throws)) - } yield None - } - - val makeBody: Generator[MethodBodyContext, Option[Expression]] = { - import paradigm.methodBodyCapabilities._ - - for { - rt <- toTargetLanguageType(TypeRep.DataType(model.baseDataType)) - _ <- resolveAndAddImport(rt) - - _ <- makeOperationSignature(rt, op) - _ <- ifStmt() - } yield None - } - - import ooParadigm.classCapabilities._ - addMethod(names.mangle(names.instanceNameOf(op)), makeBody) - } - - /** - * Each operation is placed in its own class, with a 'visit' method for each known data type. - * - * Uses the generic 'operationClass' capability to create the structure of the class. - * - * {{{ - * class Eval { } - * - * public Double op(Exp e) { - * - * } - * - * public Double _op(Lit e) { - * return e.getValue(); - * } - * - * public Double _op(Add e) { - * return op(e.left) + op(e.right) - * } - * } - * }}} - * - * @param domain Model for which all types are to be incorporated - * @param op The operation whose implementation is needed - * @param domainSpecific The EIP to gain access to the logic - * @return The one invoking this method must be sure to add this class to project. - */ - def makeOperationImplementation(domain:GenericModel, op: Operation, - domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = { - import ooParadigm.classCapabilities._ - - for { - // this will ultimately invoke makeTypeCaseImplementation for all necessary typecases - _ <- operationClass(names.addPrefix("_", names.mangle(names.instanceNameOf(op))), op, domain, domain.flatten.typeCases.distinct, domain.baseDataType, domainSpecific) - - returnTpe <- toTargetLanguageType(op.returnType) - _ <- resolveAndAddImport(returnTpe) - - _ <- makeDispatchingOperation(domain, op) - } yield () - } - - /** Just the skeleton class holding structure, since operations are designated to their own classes. */ - def makeDerived(parentType: DataType, tpeCase: DataTypeCase): Generator[ProjectContext, Unit] = { - import ooParadigm.projectCapabilities._ - val makeClass: Generator[ClassContext, Unit] = { - import ooParadigm.classCapabilities._ - for { - parent <- toTargetLanguageType(TypeRep.DataType(parentType)) - _ <- resolveAndAddImport(parent) - _ <- addParent(parent) - _ <- forEach (tpeCase.attributes) { att => makeField(att) } - _ <- addConstructor(makeConstructor(tpeCase)) - _ <- forEach (tpeCase.attributes) { att => makeGetter(att) } - - } yield () - } - addClassToProject(makeClass, names.mangle(names.conceptNameOf(tpeCase))) - } - - /** - * Define the base class for Exp which must contain the accept method as an abstract method. - * - * {{{ - * public abstract class Exp { - * public abstract R accept(Visitor v); - * } - * }}} - * - * @param tpe The DataType that needs a Base Class. - * @return - */ - def makeBase(tpe: DataType): Generator[ProjectContext, Unit] = { - import ooParadigm.projectCapabilities._ - - val makeClass: Generator[ClassContext, Unit] = { - import ooParadigm.classCapabilities._ - for { - _ <- setAbstract() - } yield () - } - - // adds the 'Exp' class, with a single accept method - addClassToProject( makeClass, names.mangle(names.conceptNameOf(tpe))) - } - - def targetExp : Generator[MethodBodyContext, Expression] = { - import paradigm.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - - for { - expRef <- getArguments().map(_.head._3) - } yield expRef - } - - /** Make a method body for each operation, which dispatches to appropriate method - * - * {{{ - * public class Eval { - public Eval() { } - public Double _eval(Add exp) { - return (new ep.Eval().eval(exp.getLeft()) + new ep.Eval().eval(exp.getRight())); - } - } - * }}} - * - * A runtime dispatcher will direct to appropriate _op() method from the op() method in class - * - * @param tpe Base Data Type. - * @param tpeCase The Data Type Case. - * @param op The operation at play. - * @param domainSpecific The EIP which contains the logic. - * @return Full implementation. - */ - override def makeTypeCaseImplementation(tpe: DataType, tpeCase: DataTypeCase, op: Operation, model: GenericModel, - domainSpecific: EvolutionImplementationProvider[this.type]): Generator[MethodBodyContext, Option[Expression]] = { - import paradigm.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - for { - returnType <- toTargetLanguageType(op.returnType) - _ <- resolveAndAddImport(returnType) - - ptype <- findClass(names.mangle(names.conceptNameOf(tpeCase))) - _ <- resolveAndAddImport(ptype) - _ <- makeOperationSignature(ptype, op) - - result <- completeImplementationFromParameters(tpe, tpeCase, op, model, domainSpecific, target=targetExp, attributeAccess = attributeDispatchAccess) - } yield result - } - - /** - * Access attributes using default getter methods via argument to method, exp - * - * @param attribute Data Type Case attribute to be accessed - * @return - */ - def attributeDispatchAccess(attribute:Attribute, tpeCase: DataTypeCase, domain:GenericModel, baseType:Option[paradigm.syntax.Type]) : Generator[MethodBodyContext, Expression] = { - import paradigm.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - - for { - expRef <- getArguments().map(_.head._3) - getterMethod <- getMember(expRef, getterName(attribute)) - getterCall <- apply(getterMethod, Seq.empty) - } yield getterCall - } - - /** - * The Runtime Dispatch approach is defined as follows - * - * 1. Make the base class (for the domain) - * 2. For each of the operations (in flattened set) create an operation class that has - * dynamic runtime checks to dispatch to appropriate method - * 3. For each data type (in flatted set) create data type class to hold information - * - * @param gdomain Top-level domain. - * @param domainSpecific Its corresponding EIP. - * @return The whole project. - */ - def implement(gdomain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = { - import ooParadigm.projectCapabilities._ - import paradigm.projectCapabilities._ - - val flat = gdomain.linearize.flatten - for { - _ <- debug ("Processing RuntimeDispatching") - _ <- strings.enable() - _ <- exceptions.enable() - _ <- registerTypeMapping(flat) - _ <- domainSpecific.initialize(this) - - // singular Exp abstract class - _ <- makeBase(flat.baseDataType) - - _ <- forEach (flat.typeCases) { tpeCase => - makeDerived(flat.baseDataType, tpeCase) - } - _ <- forEach (flat.ops) { op => - addClassToProject(makeOperationImplementation(gdomain, op, domainSpecific), names.mangle(names.conceptNameOf(op))) - } - } yield () - } -} - -object RuntimeDispatch { - type WithParadigm[P <: AnyParadigm] = RuntimeDispatch { val paradigm: P } - type WithSyntax[S <: AbstractSyntax] = WithParadigm[AnyParadigm.WithSyntax[S]] - - def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] - (base: P) - (nameProvider: NameProvider[base.syntax.Name], - impParadigmProvider: Imperative.WithBase[base.MethodBodyContext, base.type], - stringsProvider: Strings.WithBase[base.MethodBodyContext, base.type], - exceptionsProvider: Exceptions.WithBase[base.MethodBodyContext, base.type], - oo: ObjectOriented.WithBase[base.type]) : RuntimeDispatch.WithParadigm[base.type] = - new RuntimeDispatch { - val paradigm: base.type = base - val strings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type ] = stringsProvider - val impParadigm: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type ] = impParadigmProvider - val exceptions: Exceptions.WithBase[paradigm.MethodBodyContext, paradigm.type ] = exceptionsProvider - val names: NameProvider[paradigm.syntax.Name] = nameProvider - val ooParadigm: oo.type = oo - } -} diff --git a/core/src/main/scala/org/combinators/ep/domain/Evolution.scala b/core/src/main/scala/org/combinators/ep/domain/Evolution.scala index 0d17d591..2e4002a3 100644 --- a/core/src/main/scala/org/combinators/ep/domain/Evolution.scala +++ b/core/src/main/scala/org/combinators/ep/domain/Evolution.scala @@ -1,6 +1,6 @@ package org.combinators.ep.domain /*DI:LI:AI*/ -import org.combinators.ep.domain.abstractions.TestCase +import org.combinators.cogen.TestCase /** Models a point in time of an evolving data type. */ trait Evolution { diff --git a/core/src/main/scala/org/combinators/ep/domain/Model.scala b/core/src/main/scala/org/combinators/ep/domain/Model.scala index eb013a27..03c43616 100644 --- a/core/src/main/scala/org/combinators/ep/domain/Model.scala +++ b/core/src/main/scala/org/combinators/ep/domain/Model.scala @@ -1,6 +1,6 @@ package org.combinators.ep.domain /*DI:LI:AI*/ -import abstractions._ +import org.combinators.ep.domain.abstractions._ import org.combinators.ep.generator.communication.PotentialRequest /** diff --git a/core/src/main/scala/org/combinators/ep/domain/abstractions/abstractions.scala b/core/src/main/scala/org/combinators/ep/domain/abstractions/abstractions.scala index dfe7844f..5dea2e27 100644 --- a/core/src/main/scala/org/combinators/ep/domain/abstractions/abstractions.scala +++ b/core/src/main/scala/org/combinators/ep/domain/abstractions/abstractions.scala @@ -1,9 +1,12 @@ package org.combinators.ep.domain.abstractions /*DI:LI:AI*/ -import org.combinators.ep.domain.{GenericModel, abstractions} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.cogen.{InstanceRep, Tag, TestCase, TypeRep} +import org.combinators.ep.domain.GenericModel +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.matchers.Matchable +import scala.language.postfixOps + /** Models a named data type. */ case class DataType(name: String) @@ -17,7 +20,7 @@ case class DataTypeCase(name: String, attributes: Seq[Attribute]) { * implicitly given domain model. */ def isRecursive(implicit domain: GenericModel): Boolean = - attributes.exists(_.tpe == TypeRep.DataType(domain.baseDataType)) + attributes.exists(_.tpe == DomainTpeRep.DataType(domain.baseDataType)) /** Returns if this data type case contains no attributes of the data type modeled in the * implicitly given domain model. @@ -97,16 +100,13 @@ case class Attribute(name: String, tpe: TypeRep) /** Provides some default attributes. */ object Attribute { /** An attribute "inner" of the base data type of the implicitly given domain model. */ - def inner(implicit domain: GenericModel):Attribute = Attribute("inner", TypeRep.DataType(domain.baseDataType)) + def inner(implicit domain: GenericModel):Attribute = Attribute("inner", DomainTpeRep.DataType(domain.baseDataType)) /** An attribute "left" of the base data type of the implicitly given domain model. */ - def left(implicit domain: GenericModel):Attribute = Attribute("left", TypeRep.DataType(domain.baseDataType)) + def left(implicit domain: GenericModel):Attribute = Attribute("left", DomainTpeRep.DataType(domain.baseDataType)) /** An attribute "right" of the base data type of the implicitly given domain model. */ - def right(implicit domain: GenericModel):Attribute = Attribute("right", TypeRep.DataType(domain.baseDataType)) + def right(implicit domain: GenericModel):Attribute = Attribute("right", DomainTpeRep.DataType(domain.baseDataType)) } -/** Used to mark special operations (needed for isOp logic) and possible useful in other ways. */ -trait Tag { } - /** Models a named operation on a [[DataType]] with parameters and a return type, * which defaults to Unit (no return value). */ @@ -120,13 +120,13 @@ case class Operation(name: String, * In original formulation, was restricted to ONLY operations with a single parameter */ def isBinary(implicit domain: GenericModel): Boolean = - parameters.exists(param => param.tpe == TypeRep.DataType(domain.baseDataType)) + parameters.exists(param => param.tpe == DomainTpeRep.DataType(domain.baseDataType)) /** Determines if this is a producer operation, which returns an instance of * the base type of the implicitly given domain model. */ def isProducer(implicit domain: GenericModel): Boolean = - returnType == TypeRep.DataType(domain.baseDataType) + returnType == DomainTpeRep.DataType(domain.baseDataType) } /** Provides some default operations. */ @@ -134,11 +134,11 @@ object Operation { /** Models an "astree" operation, which converts a data type instance to a domain representation * [[org.combinators.ep.domain.tree.Tree]]. */ - val asTree: Operation = Operation("astree", TypeRep.Tree) + val asTree: Operation = Operation("astree", DomainTpeRep.Tree) /** Returns a [[org.combinators.ep.domain.matchers.Matchable]] transforming the given function on * [[org.combinators.ep.domain.abstractions.Parameter Parameters]] and a - * [[org.combinators.ep.domain.abstractions.TypeRep return type representation]] to a a partial function on a + * [[TypeRep return type representation]] to a a partial function on a * signature of operations of the same name as the given operation. * * Example: @@ -164,75 +164,23 @@ case class Parameter(name: String, tpe: TypeRep) /** Provides some default parameters. */ object Parameter { /** A parameter "that" of the base data type of the implicitly given domain model. */ - def that(implicit domain: GenericModel):Parameter = Parameter("that", TypeRep.DataType(domain.baseDataType)) -} - -/** Represents a host language (Scala) type within the domain. - * - * @see [[org.combinators.ep.domain.abstractions.TypeRep]] for helpers to construct representations. - */ -trait TypeRep { - /** The type to represent. */ - type HostType - - def isModelBase(model:GenericModel):Boolean = this == TypeRep.DataType(model.baseDataType) + def that(implicit domain: GenericModel):Parameter = Parameter("that", DomainTpeRep.DataType(domain.baseDataType)) } -/** Provides helpers to construct domain representations of host language types. */ -object TypeRep { - /** Representation of the host type `T`. */ - type OfHostType[T] = TypeRep { type HostType = T } - - /** Represents the Scala type `Unit`. */ - case object Unit extends TypeRep { - type HostType = scala.Unit - } - /** Represents the Scala type `String` */ - case object String extends TypeRep { - type HostType = java.lang.String - } - /** Represents the Scala type `Int`. */ - case object Int extends TypeRep { - type HostType = scala.Int - } - /** Represents the Scala type `Double`. */ - case object Double extends TypeRep { - type HostType = scala.Double - } - /** Represents the Scala type `Boolean`. */ - case object Boolean extends TypeRep { - type HostType = scala.Boolean - } +object DomainTpeRep { /** Represents the type [[org.combinators.ep.domain.tree.Tree]]. */ case object Tree extends TypeRep { type HostType = org.combinators.ep.domain.tree.Tree } - /** Represents the type `Seq[A]` */ - case class Sequence[T](elemTpe: TypeRep.OfHostType[T]) extends TypeRep { - type HostType = Seq[T] - } - /** Represents the type `Array[T]` */ - case class Array[T](elemTpe: TypeRep.OfHostType[T]) extends TypeRep { - type HostType = Array[T] - } - - /** Represents the type A => B */ - case class Arrow[A, B](src: TypeRep.OfHostType[A], tgt: TypeRep.OfHostType[B]) extends TypeRep { - type HostType = A => B - } + import org.combinators.ep.domain.abstractions.{DataType => DT} /** Represents a Scala model of an instance of the given domain specific data type. */ - case class DataType(tpe: abstractions.DataType) extends TypeRep { + case class DataType(tpe: DT) extends TypeRep { type HostType = DataTypeInstance } } -/** Marks any inheriting object as a model of a software test case. */ -trait TestCase { - val tags:Seq[Tag] = Seq.empty -} - /** Models a test case which applies operation `op` to `domainObject` and `params`, expecting a result * equal to `expected`. */ case class EqualsTestCase( @@ -249,7 +197,7 @@ object EqualsTestCase { domainObject: DataTypeInstance, op: Operation, expected: InstanceRep, - params: InstanceRep*) : EqualsTestCase = EqualsTestCase(baseTpe, domainObject, op, Seq.empty, expected, params:_*) + params: InstanceRep*) : EqualsTestCase = EqualsTestCase(baseTpe, domainObject, op, Seq.empty, expected, params*) } /** Models a test case which applies operation `op` to `domainObject` and `params`, expecting a result @@ -268,7 +216,7 @@ object NotEqualsTestCase { domainObject: DataTypeInstance, op: Operation, expected: InstanceRep, - params: InstanceRep*) : NotEqualsTestCase = NotEqualsTestCase(baseTpe, domainObject, op, Seq.empty, expected, params:_*) + params: InstanceRep*) : NotEqualsTestCase = NotEqualsTestCase(baseTpe, domainObject, op, Seq.empty, expected, params*) } /** Models a test case which sequentially applies the operations `ops` with their given parameters to the @@ -293,7 +241,7 @@ object EqualsCompositeTestCase { def apply(baseTpe: DataType, startObject: DataTypeInstance, expected: InstanceRep, - ops: (Operation, Seq[InstanceRep])*) : EqualsCompositeTestCase = EqualsCompositeTestCase(baseTpe, Seq.empty, startObject, expected, ops:_*) + ops: (Operation, Seq[InstanceRep])*) : EqualsCompositeTestCase = EqualsCompositeTestCase(baseTpe, Seq.empty, startObject, expected, ops*) } /** Models a performance test case. diff --git a/core/src/main/scala/org/combinators/ep/generator/NameProvider.scala b/core/src/main/scala/org/combinators/ep/domain/extensions/extensions.scala similarity index 70% rename from core/src/main/scala/org/combinators/ep/generator/NameProvider.scala rename to core/src/main/scala/org/combinators/ep/domain/extensions/extensions.scala index abae8e52..50f26a28 100644 --- a/core/src/main/scala/org/combinators/ep/generator/NameProvider.scala +++ b/core/src/main/scala/org/combinators/ep/domain/extensions/extensions.scala @@ -1,22 +1,22 @@ -package org.combinators.ep.generator /*DI:LI:AI*/ +package org.combinators.ep.domain.extensions /*DI:LI:AI*/ +import org.combinators.cogen.{InstanceRep, NameProvider, TypeRep} import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions._ +import org.combinators.ep.domain.instances.DataTypeInstance -/** Provides mangled names for domain entities. */ -abstract class NameProvider[Name] { - /** Mangles `name` according to language specific rules, with set . */ - def mangle(name: String): Name - - /** Adds a prefix to the given name. The new name will be mangled if necessary. */ - def addPrefix(prefix: String, name: Name): Name - - /** Adds a suffix to the given name. The new name will be mangled if necessary. */ - def addSuffix(name: Name, suffix: String): Name +/** + * EpCoGen extension of NameProvider from CoGen provides the ability to generate (capital) Names for many different concepts + * as well as (lower) names for instances of these concepts. + * + * These are done to allow, for example, a concept to become an attribute name, which is commonly lower case, vs. a class Name, + * which is commonly capitalized. + */ +extension [Name](nameProvider: NameProvider[Name]) { /** Provides the name for a language representation of concepts (e.g. classes) associated with the given Model. - * Most languages just want to return the capitalized model name. - */ + * Most languages just want to return the capitalized model name. + */ def conceptNameOf(model: GenericModel): String = model.name.capitalize @@ -39,8 +39,8 @@ abstract class NameProvider[Name] { operation.name.capitalize /** Provides the name for a language representation of concepts (e.g. attributes) associated with the given data type - * case. - * Most languages just want to return the lower case name of the case. */ + * case. + * Most languages just want to return the lower case name of the case. */ def conceptNameOf(att: Attribute): String = att.name.capitalize @@ -49,13 +49,13 @@ abstract class NameProvider[Name] { * Most languages just want to return the capitalized case name. */ def conceptNameOf(tpe: TypeRep): String = { tpe match { - case TypeRep.DataType(domainType) => conceptNameOf(domainType) + case DomainTpeRep.DataType(domainType) => conceptNameOf(domainType) case _ => tpe.getClass.getName.capitalize } } /** Provides the name for a language representation of instances (e.g. objects) associated with the given model. - * Most languages just want to return the lower case model name. */ + * Most languages just want to return the lower case model name. */ def instanceNameOf(model: GenericModel): String = model.name.toLowerCase @@ -77,8 +77,8 @@ abstract class NameProvider[Name] { operation.name.toLowerCase /** Provides the name for a language representation of instances (e.g. attributes) associated with the given data type - * case. - * Most languages just want to return the lower case name of the case. */ + * case. + * Most languages just want to return the lower case name of the case. */ def instanceNameOf(att: Attribute): String = att.name.toLowerCase @@ -87,8 +87,16 @@ abstract class NameProvider[Name] { * Most languages just want to return the capitalized type name. */ def instanceNameOf(tpe: TypeRep): String = { tpe match { - case TypeRep.DataType(domainType) => instanceNameOf(domainType) + case DomainTpeRep.DataType(domainType) => instanceNameOf(domainType) case _ => tpe.getClass.getName.toLowerCase } } } + +/** + * The extension to TypeRep makes it easy to determine when a TypeRep is in fact the type used by EpCoGen as part + * of numerous EP approaches. + */ +extension (tpe: TypeRep) { + def isModelBase(model:GenericModel):Boolean = tpe == DomainTpeRep.DataType(model.baseDataType) +} diff --git a/core/src/main/scala/org/combinators/ep/domain/instances/DataTypeInstance.scala b/core/src/main/scala/org/combinators/ep/domain/instances/DataTypeInstance.scala new file mode 100644 index 00000000..6574da89 --- /dev/null +++ b/core/src/main/scala/org/combinators/ep/domain/instances/DataTypeInstance.scala @@ -0,0 +1,39 @@ +package org.combinators.ep.domain.instances /*DI:LI:AI*/ + +/** Provides abstractions used to represent type instances of the host language (Scala) in a domain specific context and + * vice versa domain specific data types in the host language. + */ + +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.GenericModel +import org.combinators.ep.domain.abstractions.{DataTypeCase, DomainTpeRep} + + +/** Models instances of a domain specific data type in Scala. + * + * Types of the `attributeInstances` need to match the attribute types of the data type, which is also checked by + * a runtime assertion. + * + * @param tpeCase The domain type case to model. + * @param attributeInstances Instances for all attributes of the domain type. + */ +case class DataTypeInstance(tpeCase: DataTypeCase, attributeInstances: Seq[InstanceRep]) { + require({ + tpeCase.attributes.corresponds(attributeInstances) { (attribute, attributeInstance) => + attribute.tpe == attributeInstance.tpe + } + }, + "Attribute instances need to match the attribute types described in the type case" + ) + + /** Creates a new instance representation for the given domain specific data type instance using the + * base data type of the implicitly given domain model. + */ + def tpInstanceRep(implicit domain: GenericModel): InstanceRep = { + InstanceRep(DomainTpeRep.DataType(domain.baseDataType))(this) + } +} + +object DataTypeInstanceRep { + def apply(instance: DataTypeInstance)(implicit domain: GenericModel): InstanceRep = instance.tpInstanceRep +} \ No newline at end of file diff --git a/core/src/main/scala/org/combinators/ep/domain/instances/instances.scala b/core/src/main/scala/org/combinators/ep/domain/instances/instances.scala deleted file mode 100644 index f6b4ef46..00000000 --- a/core/src/main/scala/org/combinators/ep/domain/instances/instances.scala +++ /dev/null @@ -1,75 +0,0 @@ -package org.combinators.ep.domain.instances /*DI:LI:AI*/ - -/** Provides abstractions used to represent type instances of the host language (Scala) in a domain specific context and - * vice versa domain specific data types in the host language. - */ - -import org.combinators.ep.domain.GenericModel -import org.combinators.ep.domain.abstractions.{DataTypeCase, TypeRep} - -/** A host language (Scala) instance, which can be represented inside of a domain. - * - * In type theory this is encoded as a dependent sum, Sigma, where there exists a type and an instance for that type. - * Check [[https://partialflow.wordpress.com/2017/07/26/dependent-types-type-level-programming/ this introduction]] - * on dependent types in Scala. - * - * The type of the instance is captured by 'tpe' - * - * @see The companion model [[org.combinators.ep.domain.instances.InstanceRep]] for creating new instances. - */ -sealed trait InstanceRep { - /** Provides the domain representation of the instance type. */ - val tpe: TypeRep - /** Provides the host language (Scala) instance. */ - val inst: tpe.HostType - - override def hashCode(): Int = inst.hashCode() - override def equals(obj: Any): Boolean = { - obj match { - case that: InstanceRep => - that.isInstanceOf[InstanceRep.OfHostType[tpe.HostType]] && inst == that.inst - case _ => false - } - } -} - -/** Provides methods for wrapping host language (Scala) instances into domain representable entities. */ -object InstanceRep { - /** Type of represented instances of a given host language (Scala) type. */ - type OfHostType[T] = InstanceRep {val tpe: TypeRep.OfHostType[T]} - - /** Creates a new instance representation for the given representable host language type and an instance of it. */ - def apply(tpe: TypeRep)(inst: tpe.HostType): InstanceRep = { - val tpeArg: tpe.type = tpe - val instArg: tpeArg.HostType = inst - new InstanceRep { - val tpe: tpeArg.type = tpeArg - val inst: tpeArg.HostType = instArg - } - } - - /** Creates a new instance representation for the given domain specific data type instance using the - * base data type of the implicitly given domain model. - */ - def apply(inst: DataTypeInstance)(implicit domain: GenericModel): InstanceRep = { - InstanceRep(TypeRep.DataType(domain.baseDataType))(inst) - } -} - -/** Models instances of a domain specific data type in Scala. - * - * Types of the `attributeInstances` need to match the attribute types of the data type, which is also checked by - * a runtime assertion. - * - * @param tpeCase The domain type case to model. - * @param attributeInstances Instances for all attributes of the domain type. - */ -case class DataTypeInstance(tpeCase: DataTypeCase, attributeInstances: Seq[InstanceRep]) { - require({ - tpeCase.attributes.corresponds(attributeInstances) { (attribute, attributeInstance) => - attribute.tpe == attributeInstance.tpe - } - }, - "Attribute instances need to match the attribute types described in the type case" - ) -} diff --git a/core/src/main/scala/org/combinators/ep/domain/matchers/Matchable.scala b/core/src/main/scala/org/combinators/ep/domain/matchers/Matchable.scala index 5a145e3b..04ebc0ac 100644 --- a/core/src/main/scala/org/combinators/ep/domain/matchers/Matchable.scala +++ b/core/src/main/scala/org/combinators/ep/domain/matchers/Matchable.scala @@ -1,6 +1,7 @@ package org.combinators.ep.domain.matchers /*DI:LI:AI*/ -import scala.language.reflectiveCalls +import scala.reflect.Selectable.reflectiveSelectable // needed for Matchable + /** Provides programmatic pattern matching abstractions. */ /** Converts things of type `Source` into things of type `Content` if the source objects match a criterion. */ @@ -22,40 +23,29 @@ object Matchable { * function succeeds. */ def named[Source <: {val name: String}, Content]( - name: String, - project: PartialFunction[Source, Content] - ): Matchable[Source, Content] = new Matchable[Source, Content] { - override def toContent(source: Source): Option[Content] = - if (source.name == name) project.lift(source) - else None - } + name: String, + project: PartialFunction[Source, Content] + ): Matchable[Source, Content] = (source: Source) => if (source.name == name) project.lift(source) + else None /** Returns a `Matchable` that only matches if the given projection function returns a singleton sequence. */ def unary[Source, Content](project: PartialFunction[Source, Seq[Content]]): Matchable[Source, Content] = - new Matchable[Source, Content] { - override def toContent(source: Source): Option[Content] = - project.lift.apply(source) match { - case Some(Seq(content)) => Some(content) - case _ => None - } + (source: Source) => project.lift.apply(source) match { + case Some(Seq(content)) => Some(content) + case _ => None } /** Returns a `Matchable` that only matches if the given partial projection function returns a sequence of exactly * two objects. */ def binary[Source, Content](project: PartialFunction[Source, Seq[Content]]): Matchable[Source, (Content, Content)] = - new Matchable[Source, (Content, Content)] { - override def toContent(source: Source): Option[(Content, Content)] = - project.lift.apply(source) match { - case Some(Seq(left, right)) => Some(left, right) - case _ => None - } + (source: Source) => project.lift.apply(source) match { + case Some(Seq(left, right)) => Some(left, right) + case _ => None } /** Returns a `Matchable` that matches anything by converting it into a sequence of contents. */ def nary[Source, Content](project: PartialFunction[Source, Seq[Content]]): Matchable[Source, Seq[Content]] = - new Matchable[Source, Seq[Content]] { - override def toContent(source: Source): Option[Seq[Content]] = project.lift.apply(source) - } + (source: Source) => project.lift.apply(source) } diff --git a/core/src/main/scala/org/combinators/ep/domain/tree/tree.scala b/core/src/main/scala/org/combinators/ep/domain/tree/tree.scala index 7f57fbd3..f1184c9c 100644 --- a/core/src/main/scala/org/combinators/ep/domain/tree/tree.scala +++ b/core/src/main/scala/org/combinators/ep/domain/tree/tree.scala @@ -1,7 +1,8 @@ package org.combinators.ep.domain.tree /*DI:LI:AI*/ /** Provides models of generic trees. */ -import org.combinators.ep.domain.instances.InstanceRep + +import org.combinators.cogen.InstanceRep /** Models a generic int-labeled tree with data of any type stored in its leaves. */ sealed trait Tree diff --git a/core/src/main/scala/org/combinators/ep/generator/ApproachImplementationProvider.scala b/core/src/main/scala/org/combinators/ep/generator/ApproachImplementationProvider.scala index 35e756f8..df3000fe 100644 --- a/core/src/main/scala/org/combinators/ep/generator/ApproachImplementationProvider.scala +++ b/core/src/main/scala/org/combinators/ep/generator/ApproachImplementationProvider.scala @@ -3,11 +3,14 @@ package org.combinators.ep.generator /*DI:LI:AI*/ import org.combinators.ep.domain._ import abstractions._ import communication._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} - -import org.combinators.ep.generator.Command._ -import org.combinators.ep.generator.paradigm.{AddImport, AnyParadigm, ResolveImport} +import extensions._ +import org.combinators.cogen.paradigm.{AddImport, AnyParadigm, ResolveImport} +import org.combinators.ep.domain.instances.DataTypeInstance +import org.combinators.cogen.Command._ import AnyParadigm.syntax._ +import org.combinators.cogen.{AbstractSyntax, InstanceRep, NameProvider, TestCase, Understands} + +import scala.language.postfixOps /** Provides implementations for language and approach specific code generation tasks which do not depend on a specific * EP domain. */ @@ -44,7 +47,7 @@ trait ApproachImplementationProvider { def instantiate(baseType: DataType, inst: DataTypeInstance): Generator[MethodBodyContext, Expression] = { for { attributeInstances <- forEach (inst.attributeInstances) { ati => reify(ati) } - result <- instantiate(baseType, inst.tpeCase, attributeInstances: _*) + result <- instantiate(baseType, inst.tpeCase, attributeInstances*) } yield result } @@ -60,7 +63,7 @@ trait ApproachImplementationProvider { /** Converts a Scala model of an instance of any representable type into code. */ def reify(inst: InstanceRep): Generator[MethodBodyContext, Expression] = { (inst.tpe, inst.inst) match { - case (TypeRep.DataType(baseTpe), domInst: DataTypeInstance) => instantiate(baseTpe, domInst) + case (DomainTpeRep.DataType(baseTpe), domInst: DataTypeInstance) => instantiate(baseTpe, domInst) case (tpe, inst) => import paradigm.methodBodyCapabilities._ for { @@ -68,7 +71,6 @@ trait ApproachImplementationProvider { _ <- resolveAndAddImport(resTy) res <- methodBodyCapabilities.reify[tpe.HostType](tpe, inst.asInstanceOf[tpe.HostType]) } yield res - case _ => throw new scala.NotImplementedError(s"No rule to compile instantiations of ${inst.tpe}.") } } diff --git a/core/src/main/scala/org/combinators/ep/generator/EvolutionImplementationProvider.scala b/core/src/main/scala/org/combinators/ep/generator/EvolutionImplementationProvider.scala index 8465ae18..5a04f5bb 100644 --- a/core/src/main/scala/org/combinators/ep/generator/EvolutionImplementationProvider.scala +++ b/core/src/main/scala/org/combinators/ep/generator/EvolutionImplementationProvider.scala @@ -1,11 +1,15 @@ package org.combinators.ep.generator /*DI:LI:AI*/ import cats.kernel.Monoid +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.FFI import org.combinators.ep.domain.GenericModel import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command +import Command.Generator import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm + +import scala.language.postfixOps /** Instances of this class provide the domain dependent implementation of an evolution. */ trait EvolutionImplementationProvider[-AIP <: ApproachImplementationProvider] { @@ -13,7 +17,7 @@ trait EvolutionImplementationProvider[-AIP <: ApproachImplementationProvider] { val model: GenericModel /** Initializes the project context to support this evolution, e.g. by calling - * [[org.combinators.ep.generator.paradigm.ffi.FFI.enable()]] for all the required FFIs. + * [[FFI.enable()]] for all the required FFIs. */ def initialize(forApproach: AIP): Generator[forApproach.paradigm.ProjectContext, Unit] @@ -80,7 +84,7 @@ trait EvolutionImplementationProvider[-AIP <: ApproachImplementationProvider] { )) } - res <- forApproach.instantiate(model.baseDataType, dt, processedAtts : _ *) + res <- forApproach.instantiate(model.baseDataType, dt, processedAtts*) } yield Some(res) } } @@ -103,16 +107,7 @@ object EvolutionImplementationProvider { def empty: EvolutionImplementationProvider[AIP] = new EvolutionImplementationProvider[AIP] { override val model:GenericModel = ??? // won't ever access def initialize(forApproach: AIP): Generator[forApproach.paradigm.ProjectContext, Unit] = Command.skip -// override def applicableIn -// (forApproach: AIP) -// (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression], current:GenericModel): Option[GenericModel] = None -// override def applicableIn(forApproach: AIP, onRequest: PotentialRequest, current:GenericModel): Option[GenericModel] = None -// -// override def applicable -// (forApproach: AIP) -// (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Boolean = false -// override def applicable -// (forApproach: AIP, onRequest: PotentialRequest): Boolean = false + override def genericLogic (forApproach: AIP) (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]) = @@ -131,20 +126,7 @@ object EvolutionImplementationProvider { ): EvolutionImplementationProvider[AIP] = new EvolutionImplementationProvider[AIP] { // bias is to use the first - override val model = first.model - -// @Deprecated override def dependencies(op: Operation, dt: DataTypeCase): Option[Set[Operation]] = { -// (first.dependencies(op, dt), second.dependencies(op, dt)) match { -// case (None, None) => None -// case (Some(deps1), Some(deps2)) => Some(deps1 ++ deps2) -// case (Some(deps1), _) => Some(deps1) -// case (_, deps) => deps -// } -// } -// -// /** Ensure dependencies are union'd through composition. */ -// @Deprecated override def evolutionSpecificDependencies(op:Operation, dt:DataTypeCase) : Map[GenericModel, Set[Operation]] = -// second.evolutionSpecificDependencies(op, dt) ++ first.evolutionSpecificDependencies(op, dt) + override val model: GenericModel = first.model override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { (first.dependencies(potentialRequest), second.dependencies(potentialRequest)) match { diff --git a/core/src/main/scala/org/combinators/ep/generator/TestImplementationProvider.scala b/core/src/main/scala/org/combinators/ep/generator/TestImplementationProvider.scala index 12a1a8cd..ac8ba99e 100644 --- a/core/src/main/scala/org/combinators/ep/generator/TestImplementationProvider.scala +++ b/core/src/main/scala/org/combinators/ep/generator/TestImplementationProvider.scala @@ -1,12 +1,13 @@ package org.combinators.ep.generator /*DI:LI:AI*/ import cats.kernel.Monoid -import org.combinators.ep.domain.abstractions.{DataType, EqualsCompositeTestCase, EqualsTestCase, NotEqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Assertions, Booleans, Equality, Strings} +import org.combinators.cogen.{Command, InstanceRep, TestCase, TypeRep} +import org.combinators.ep.domain.abstractions._ +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.generator.communication.{Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Assertions, Booleans, Equality, Strings} trait TestImplementationProvider[-AIP <: ApproachImplementationProvider] { def initialize(forApproach: AIP): Generator[forApproach.paradigm.ProjectContext, Unit] @@ -47,7 +48,7 @@ object TestImplementationProvider { } } - def defaultAssertionBasedTests[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] + def defaultAssertionBasedTests[P <: AnyParadigm, AIP[T <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[T]] (paradigm: P) (ffiAssertions: Assertions.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], @@ -71,10 +72,10 @@ object TestImplementationProvider { expected: InstanceRep, argInsts: Seq[InstanceRep] ): Generator[forApproach.paradigm.MethodBodyContext, (forApproach.paradigm.syntax.Type, forApproach.paradigm.syntax.Expression, forApproach.paradigm.syntax.Expression)] = { - import forApproach.paradigm.methodBodyCapabilities._ import AnyParadigm.syntax._ + import forApproach.paradigm.methodBodyCapabilities._ for { - tpe <- toTargetLanguageType(TypeRep.DataType(baseTpe)) + tpe <- toTargetLanguageType(DomainTpeRep.DataType(baseTpe)) _ <- forApproach.resolveAndAddImport(tpe) exp <- forApproach.reify(expected) inst <- forApproach.instantiate(baseTpe, domainObject) @@ -99,8 +100,8 @@ object TestImplementationProvider { def makeNotEqualsTestCase(forApproach: AIP[paradigm.type])(testCase: NotEqualsTestCase): Generator[forApproach.paradigm.MethodBodyContext, Seq[forApproach.paradigm.syntax.Expression]] = { import ffiAssertions.assertionCapabilities._ - import ffiEquality.equalityCapabilities._ import ffiBooleans.booleanCapabilities._ + import ffiEquality.equalityCapabilities._ for { (tpe, res, exp) <- prepareTestCase(forApproach)(testCase.baseTpe, testCase.domainObject, testCase.op, testCase.expected, testCase.params) assertion <- assertNotEquals(tpe, res, exp) @@ -109,12 +110,12 @@ object TestImplementationProvider { def makeEqualsCompositeTestCase(forApproach: AIP[paradigm.type])(testCase: EqualsCompositeTestCase): Generator[forApproach.paradigm.MethodBodyContext, Seq[forApproach.paradigm.syntax.Expression]] = { + import AnyParadigm.syntax._ import ffiAssertions.assertionCapabilities._ import ffiEquality.equalityCapabilities._ import forApproach.paradigm._ import methodBodyCapabilities._ import syntax._ - import AnyParadigm.syntax._ def makeChain(tpe: TypeRep, obj: Expression, ops: Seq[(Operation, Seq[InstanceRep])]): Generator[MethodBodyContext, (Type, Expression)] = ops match { @@ -124,7 +125,7 @@ object TestImplementationProvider { requestArgs = op.parameters.zip(args).toMap nextObj <- tpe match { - case TypeRep.DataType(dtpe) => + case DomainTpeRep.DataType(dtpe) => forApproach.dispatch(SendRequest(obj, dtpe, Request(op, requestArgs))) case _ if ops.nonEmpty => throw new RuntimeException(s"Intermediate results in composite test cases must be domain data types (cannot dispatch to: $tpe)") @@ -138,11 +139,11 @@ object TestImplementationProvider { } for { - tpe <- toTargetLanguageType(TypeRep.DataType(testCase.baseTpe)) + tpe <- toTargetLanguageType(DomainTpeRep.DataType(testCase.baseTpe)) _ <- forApproach.resolveAndAddImport(tpe) exp <- forApproach.reify(testCase.expected) inst <- forApproach.instantiate(testCase.baseTpe, testCase.startObject) - (resTpe, res) <- makeChain(TypeRep.DataType(testCase.baseTpe), inst, testCase.ops) + (resTpe, res) <- makeChain(DomainTpeRep.DataType(testCase.baseTpe), inst, testCase.ops) assertion <- assertEquals(resTpe, res, exp) } yield Seq(assertion) } diff --git a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Trees.scala b/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Trees.scala index 107977c8..37d1f7ce 100644 --- a/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Trees.scala +++ b/core/src/main/scala/org/combinators/ep/generator/paradigm/ffi/Trees.scala @@ -1,15 +1,16 @@ -package org.combinators.ep.generator.paradigm.ffi /*DI:LI:AI*/ +package org.combinators.ep.generator.paradigm.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.ffi.FFI +import org.combinators.cogen.paradigm.{AnyParadigm, Apply} +import org.combinators.cogen.Understands case class CreateLeaf[Type](valueType: Type) case class CreateNode() trait Trees[Context] extends FFI { - import base._ - import syntax._ + import base.* + import syntax.* trait TreeCapabilities { implicit val canCreateLeaf: Understands[Context, Apply[CreateLeaf[Type], Expression, Expression]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/A1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/A1.scala index 32cf2fc6..97505a9f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/A1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/A1.scala @@ -1,26 +1,25 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.{Evolution, GenericModel} -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} import org.combinators.ep.domain.math.systemI.I1 -// Yes this is "Times" but I wanted to get something quick and dirty. Better to replace -// with Abs(...) which returns absolute value of expression, but wanted this to be binary. +// Yes this is "Times" but I wanted to get something quick and dirty. object A1 extends Evolution { override implicit def getModel:GenericModel = I1.getModel.evolve("a1", Seq(Times), Seq.empty) - // a1:model evolution. - // ------------------- - lazy val Times = DataTypeCase.binary("Times")(MathDomain.getModel) + lazy val Times: DataTypeCase = DataTypeCase.binary("Times")(MathDomain.getModel) def TimesInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Times, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Times, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val a1_m3_m2 = TimesInst(LitInst(5.0), LitInst(2.0)) + val a1_m3_m2: DataTypeInstance = TimesInst(LitInst(5.0), LitInst(2.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(I1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3.scala index 13b37b7c..fbc7b641 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3.scala @@ -1,8 +1,9 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.{DataTypeInstance, DataTypeInstanceRep} +import org.combinators.cogen.TestCase import org.combinators.ep.domain.{Evolution, GenericModel} -import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, TestCase} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.ep.domain.abstractions.EqualsCompositeTestCase import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.M3.MultInst import org.combinators.ep.domain.math.systemI.I1 @@ -11,13 +12,13 @@ object A1M3 extends Evolution { override implicit def getModel:GenericModel = M3.getModel.extend("a1m3", Seq(A1.getModel)) // Tests - val a1m3_t = MultInst(LitInst(5.0), LitInst(2.0)) + val a1m3_t: DataTypeInstance = MultInst(LitInst(5.0), LitInst(2.0)) /** Could include new tests here, and new ones */ override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M3, A1) def tests: Seq[TestCase] = Seq( - EqualsCompositeTestCase(getModel.baseDataType, a1m3_t, M0.DoubleInst(30.0), (I1.MultBy, Seq(InstanceRep(LitInst(3.0)))), (Eval, Seq.empty)) + EqualsCompositeTestCase(getModel.baseDataType, a1m3_t, M0.DoubleInst(30.0), (I1.MultBy, Seq(DataTypeInstanceRep(LitInst(3.0)))), (Eval, Seq.empty)) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3I2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3I2.scala index 0768bb7b..118cb315 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3I2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/A1M3I2.scala @@ -1,7 +1,7 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain.{Evolution, GenericModel} -import org.combinators.ep.domain.abstractions.TestCase import org.combinators.ep.domain.math.systemI.I2 object A1M3I2 extends Evolution { @@ -9,7 +9,6 @@ object A1M3I2 extends Evolution { override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(A1M3, I2) - // testing def tests: Seq[TestCase] = Seq( ) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/A3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/A3.scala index 9be69603..5106dad5 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/A3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/A3.scala @@ -1,8 +1,10 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.{Evolution, GenericModel} -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} @@ -21,21 +23,17 @@ m0 <- m1 <- m2 <- i1 <- a1 [Mult] | object A3 extends Evolution { override implicit def getModel:GenericModel = A1M3I2.getModel.evolve("a3", Seq(Inv), Seq.empty) - // A3:model evolution. INV which is opposite of DIV - // ------------------- - lazy val Inv = DataTypeCase.binary("Inv")(MathDomain.getModel) + lazy val Inv: DataTypeCase = DataTypeCase.binary("Inv")(MathDomain.getModel) def DivdInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Inv, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Inv, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val m3_m2_d1 = DivdInst(LitInst(5.0), LitInst(2.0)) + val m3_m2_d1: DataTypeInstance = DivdInst(LitInst(5.0), LitInst(2.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(A1M3I2) - def tests: Seq[TestCase] = Seq( - EqualsTestCase(getModel.baseDataType, m3_m2_d1, PrettyP, StringInst("(2.0/5.0)")), EqualsTestCase(getModel.baseDataType, m3_m2_d1, Eval, M0.DoubleInst(0.4)), ) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/C2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/C2.scala index e4817f26..89c8e6ed 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/C2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/C2.scala @@ -1,8 +1,11 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, Eval, LitInst} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} @@ -13,32 +16,29 @@ object C2 extends Evolution { def ListDoubleInst(doubles:Seq[scala.Double]): InstanceRep = InstanceRep(TypeRep.Sequence(TypeRep.Double))(doubles) - lazy val Collect = Operation("collect", TypeRep.Sequence(TypeRep.Double)) + lazy val Collect: Operation = Operation("collect", TypeRep.Sequence(TypeRep.Double)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(Q1) - // Tests - // (5/7) / (7-(2*3) --> just (5/7) - - val m4_m1 = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) - val m4_m2 = MultInst(LitInst(2.0), LitInst(3.0)) - val m4_d2 = DivdInst(DivdInst(LitInst(5.0), LitInst(7.0)), SubInst(LitInst(7.0), m4_m2)) + val m4_m1: DataTypeInstance = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) + val m4_m2: DataTypeInstance = MultInst(LitInst(2.0), LitInst(3.0)) + val m4_d2: DataTypeInstance = DivdInst(DivdInst(LitInst(5.0), LitInst(7.0)), SubInst(LitInst(7.0), m4_m2)) - val m4_s_0 = NegInst(LitInst(0.0)) - val m4_s_5 = AddInst(LitInst(5.0), LitInst(0.0)) - val m4_s_00 = AddInst(LitInst(0.0), LitInst(0.0)) - val m4_s_7 = AddInst(LitInst(0.0), LitInst(7.0)) + val m4_s_0: DataTypeInstance = NegInst(LitInst(0.0)) + val m4_s_5: DataTypeInstance = AddInst(LitInst(5.0), LitInst(0.0)) + val m4_s_00: DataTypeInstance = AddInst(LitInst(0.0), LitInst(0.0)) + val m4_s_7: DataTypeInstance = AddInst(LitInst(0.0), LitInst(7.0)) // validates simplify ((5+0)+(0+7)) = (5+7) - val m4_together = AddInst(m4_s_5, m4_s_7) - val m4_s_13 = MultInst(LitInst(13.0), LitInst(1.0)) - val m4_s_12 = MultInst(LitInst(1.0), LitInst(12.0)) - val m4_s_m0 = SubInst(LitInst(7.0), LitInst(7.0)) + val m4_together: DataTypeInstance = AddInst(m4_s_5, m4_s_7) + val m4_s_13: DataTypeInstance = MultInst(LitInst(13.0), LitInst(1.0)) + val m4_s_12: DataTypeInstance = MultInst(LitInst(1.0), LitInst(12.0)) + val m4_s_m0: DataTypeInstance = SubInst(LitInst(7.0), LitInst(7.0)) - val m4_s_n1 = DivdInst(LitInst(5.0), LitInst(-5.0)) - val m4_s_1 = DivdInst(LitInst(-5.0), LitInst(-5.0)) - val m4_s_d0 = DivdInst(LitInst(0.0), LitInst(-5.0)) + val m4_s_n1: DataTypeInstance = DivdInst(LitInst(5.0), LitInst(-5.0)) + val m4_s_1: DataTypeInstance = DivdInst(LitInst(-5.0), LitInst(-5.0)) + val m4_s_d0: DataTypeInstance = DivdInst(LitInst(0.0), LitInst(-5.0)) /** * Test cases for Simplify are oddly complicated. The Simplify operation returns a new Exp object, but @@ -56,6 +56,5 @@ object C2 extends Evolution { EqualsTestCase(getModel.baseDataType, m4_m1, PrettyP, StringInst("((5.0/2.0)*4.0)")), EqualsTestCase(getModel.baseDataType, m4_m1, Eval, M0.DoubleInst(10.0)), - ) // - + ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/I2M3I1N1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/I2M3I1N1.scala index 606a3f24..72ace062 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/I2M3I1N1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/I2M3I1N1.scala @@ -1,6 +1,6 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.TestCase +import org.combinators.cogen.TestCase import org.combinators.ep.domain.math.systemI.I2 import org.combinators.ep.domain.{Evolution, GenericModel} diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M0.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M0.scala index 91a739b7..7c0e5cc8 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M0.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M0.scala @@ -1,17 +1,22 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.instances._ object M0 extends Evolution { override implicit def getModel:GenericModel = MathDomain.baseModel.evolve("m0", Seq(Lit, Add), Seq(Eval)) - lazy val litValue = Attribute ("value", TypeRep.Double) - lazy val Lit = DataTypeCase("Lit", Seq(litValue)) - lazy val Add = DataTypeCase.binary("Add")(MathDomain.getModel) + lazy val litValue: Attribute = Attribute("value", TypeRep.Double) - lazy val Eval = Operation("eval", TypeRep.Double) + lazy val Lit: DataTypeCase = DataTypeCase("Lit", Seq(litValue)) + lazy val Add: DataTypeCase = DataTypeCase.binary("Add")(MathDomain.getModel) + + lazy val Eval: Operation = Operation("eval", TypeRep.Double) def DoubleInst(d: scala.Double): InstanceRep = InstanceRep(TypeRep.Double)(d) @@ -21,10 +26,10 @@ object M0 extends Evolution { DataTypeInstance(Lit, Seq(DoubleInst(d))) def AddInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Add, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Add, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) - val addi:DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) - val liti:DataTypeInstance = LitInst(5.0) + val addi: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val liti: DataTypeInstance = LitInst(5.0) // defining tests exactly once means they can be eliminated later (in Evolution) when it uses 'distinct' on past test cases) val m0_test_1: TestCase = EqualsTestCase(getModel.baseDataType, addi, Eval, DoubleInst(3.0)) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M1.scala index 4697b604..4bc12480 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M1.scala @@ -1,20 +1,19 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} -import org.combinators.ep.domain.math.M1.{SubInst, getModel} object M1 extends Evolution { override implicit def getModel:GenericModel = M0.getModel.evolve("m1", Seq(Sub), Seq.empty) - // m1:model evolution. - // ------------------- lazy val Sub:DataTypeCase = DataTypeCase.binary("Sub")(MathDomain.getModel) def SubInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Sub, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Sub, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M0) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M2.scala index f362d57f..fb1c5d7f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M2.scala @@ -1,8 +1,11 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.{Tag, TestCase} import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, LitInst} import org.combinators.ep.domain.math.M1.SubInst @@ -11,10 +14,10 @@ object M2 extends Evolution { def StringInst(s:String): InstanceRep = InstanceRep(TypeRep.String)(s) - lazy val PrettyP = Operation("prettyp", TypeRep.String) + lazy val PrettyP: Operation = Operation("prettyp", TypeRep.String) // Tests - val m2_s1 = SubInst(LitInst(1.0), LitInst(2.0)) + val m2_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(2.0)) case object LitPrettyPM2 extends Tag diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M2_ABS.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M2_ABS.scala index 65e18f60..13f19801 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M2_ABS.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M2_ABS.scala @@ -1,24 +1,24 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.{InstanceRep, TestCase} import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} -import org.combinators.ep.domain.math.M0.{AddInst, LitInst} +import org.combinators.ep.domain.instances.DataTypeInstance +import org.combinators.ep.domain.math.M0.LitInst import org.combinators.ep.domain.math.M1.SubInst object M2_ABS extends Evolution { override implicit def getModel:GenericModel = M2.getModel.evolve("m2_abs", Seq(Abs), Seq.empty) - // m1:model evolution. - // ------------------- lazy val Abs:DataTypeCase = DataTypeCase.unary("Abs")(MathDomain.getModel) - val m2_abs_s1 = SubInst(LitInst(1.0), LitInst(2.0)) - val m2_abs_a1 = AbsInst(m2_abs_s1) - val m2_abs_r1 = M0.DoubleInst(1.0) + val m2_abs_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(2.0)) + val m2_abs_a1: DataTypeInstance = AbsInst(m2_abs_s1) + val m2_abs_r1: InstanceRep = M0.DoubleInst(1.0) def AbsInst(inner:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Abs, Seq(InstanceRep(inner))) + DataTypeInstance(Abs, Seq(DataTypeInstanceRep(inner))) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M2) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M3.scala index 35d52a3a..1fcf30ad 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M3.scala @@ -1,5 +1,6 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.instances._ @@ -9,25 +10,23 @@ import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} object M3 extends Evolution { override implicit def getModel:GenericModel = M2.getModel.evolve("m3", Seq(Neg, Mult, Divd), Seq.empty) - // m3:model evolution. - // ------------------- - lazy val Mult = DataTypeCase.binary("Mult")(MathDomain.getModel) - lazy val Neg = DataTypeCase.unary("Neg")(MathDomain.getModel) - lazy val Divd = DataTypeCase.binary("Divd")(MathDomain.getModel) + lazy val Mult: DataTypeCase = DataTypeCase.binary("Mult")(MathDomain.getModel) + lazy val Neg: DataTypeCase = DataTypeCase.unary("Neg")(MathDomain.getModel) + lazy val Divd: DataTypeCase = DataTypeCase.binary("Divd")(MathDomain.getModel) def NegInst(inner:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Neg, Seq(InstanceRep(inner))) + DataTypeInstance(Neg, Seq(DataTypeInstanceRep(inner))) def MultInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Mult, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Mult, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) def DivdInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Divd, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Divd, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val m3_d1 = NegInst(LitInst(5.0)) - val m3_s1 = NegInst(MultInst(LitInst(2.0), LitInst(3.0))) + val m3_d1: DataTypeInstance = NegInst(LitInst(5.0)) + val m3_s1: DataTypeInstance = NegInst(MultInst(LitInst(2.0), LitInst(3.0))) - val m3_m1 = NegInst(LitInst(1.0)) - val m3_m2 = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) + val m3_m1: DataTypeInstance = NegInst(LitInst(1.0)) + val m3_m2: DataTypeInstance = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M2) @@ -48,5 +47,4 @@ object M3 extends Evolution { m3_test_5, m3_test_6 ) - } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M3I1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M3I1.scala index 2de4071a..bd6c7607 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M3I1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M3I1.scala @@ -1,6 +1,6 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.TestCase +import org.combinators.cogen.TestCase import org.combinators.ep.domain.math.systemI.I1 import org.combinators.ep.domain.{Evolution, GenericModel} diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M3W1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M3W1.scala index ec258397..7b018506 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M3W1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M3W1.scala @@ -1,14 +1,13 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.{DataTypeCase, TestCase} object M3W1 extends Evolution { override implicit def getModel:GenericModel = M3.getModel.extend("m3w1", Seq(W1.getModel)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M3, W1) - // testing def tests: Seq[TestCase] = Seq( ) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M4.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M4.scala index 1794ea73..e1f89f95 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M4.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M4.scala @@ -1,8 +1,10 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.{TestCase, TypeRep} import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.ep.domain.abstractions.{DomainTpeRep, EqualsCompositeTestCase, EqualsTestCase, Operation} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, Eval, LitInst} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} @@ -12,36 +14,30 @@ object M4 extends Evolution { override implicit def getModel:GenericModel = M3.getModel.evolve("m4", Seq.empty, Seq(Simplify, Collect)) // this is a producer method (as you can tell by its return type). - lazy val Simplify = Operation("simplify", TypeRep.DataType(MathDomain.getModel.baseDataType)) - - // m4:model evolution. - // ------------------- + lazy val Simplify: Operation = Operation("simplify", DomainTpeRep.DataType(MathDomain.getModel.baseDataType)) def ListDoubleInst(doubles:Seq[scala.Double]): InstanceRep = InstanceRep(TypeRep.Sequence(TypeRep.Double))(doubles) - lazy val Collect = Operation("collect", TypeRep.Sequence(TypeRep.Double)) + lazy val Collect: Operation = Operation("collect", TypeRep.Sequence(TypeRep.Double)) // Tests - // (5/7) / (7-(2*3) --> just (5/7) - - val m4_m1 = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) - val m4_m2 = MultInst(LitInst(2.0), LitInst(3.0)) - val m4_d2 = DivdInst(DivdInst(LitInst(5.0), LitInst(7.0)), SubInst(LitInst(7.0), m4_m2)) - - val m4_s_0 = NegInst(LitInst(0.0)) - val m4_s_5 = AddInst(LitInst(5.0), LitInst(0.0)) - val m4_s_00 = AddInst(LitInst(0.0), LitInst(0.0)) - val m4_s_7 = AddInst(LitInst(0.0), LitInst(7.0)) - - // validates simplify ((5+0)+(0+7)) = (5+7) - val m4_together = AddInst(m4_s_5, m4_s_7) - val m4_s_13 = MultInst(LitInst(13.0), LitInst(1.0)) - val m4_s_12 = MultInst(LitInst(1.0), LitInst(12.0)) - val m4_s_m0 = SubInst(LitInst(7.0), LitInst(7.0)) - - val m4_s_n1 = DivdInst(LitInst(5.0), LitInst(-5.0)) - val m4_s_1 = DivdInst(LitInst(-5.0), LitInst(-5.0)) - val m4_s_d0 = DivdInst(LitInst(0.0), LitInst(-5.0)) + val m4_m1: DataTypeInstance = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) + val m4_m2: DataTypeInstance = MultInst(LitInst(2.0), LitInst(3.0)) + val m4_d2: DataTypeInstance = DivdInst(DivdInst(LitInst(5.0), LitInst(7.0)), SubInst(LitInst(7.0), m4_m2)) + + val m4_s_0: DataTypeInstance = NegInst(LitInst(0.0)) + val m4_s_5: DataTypeInstance = AddInst(LitInst(5.0), LitInst(0.0)) + val m4_s_00: DataTypeInstance = AddInst(LitInst(0.0), LitInst(0.0)) + val m4_s_7: DataTypeInstance = AddInst(LitInst(0.0), LitInst(7.0)) + + val m4_together: DataTypeInstance = AddInst(m4_s_5, m4_s_7) + val m4_s_13: DataTypeInstance = MultInst(LitInst(13.0), LitInst(1.0)) + val m4_s_12: DataTypeInstance = MultInst(LitInst(1.0), LitInst(12.0)) + val m4_s_m0: DataTypeInstance = SubInst(LitInst(7.0), LitInst(7.0)) + + val m4_s_n1: DataTypeInstance = DivdInst(LitInst(5.0), LitInst(-5.0)) + val m4_s_1: DataTypeInstance = DivdInst(LitInst(-5.0), LitInst(-5.0)) + val m4_s_d0: DataTypeInstance = DivdInst(LitInst(0.0), LitInst(-5.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M3) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M5.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M5.scala index 014e85ca..9bf98f29 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M5.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M5.scala @@ -1,10 +1,12 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.{TestCase, TypeRep} import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, EqualsCompositeTestCase, EqualsTestCase, Operation} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.tree._ -import org.combinators.ep.domain.math.M0.{Lit, Add, AddInst, LitInst, DoubleInst} +import org.combinators.ep.domain.math.M0.{Add, AddInst, DoubleInst, Lit, LitInst} import org.combinators.ep.domain.math.M1.{Sub, SubInst} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} import org.combinators.ep.domain.math.M3.{Divd, DivdInst, Mult, MultInst, Neg, NegInst} @@ -12,13 +14,14 @@ import org.combinators.ep.domain.math.M4.Simplify object M5 extends Evolution { override implicit def getModel:GenericModel = M4.getModel.evolve("m5", Seq.empty, Seq(Operation.asTree, Identifier)) - lazy val Identifier = Operation("id", TypeRep.Int) - val m5_s1 = SubInst(LitInst(1.0), LitInst(976.0)) - val m5_s2 = AddInst(LitInst(1.0), LitInst(976.0)) - val m5_s3 = SubInst(LitInst(1.0), LitInst(976.0)) + lazy val Identifier: Operation = Operation("id", TypeRep.Int) - val m5_all = SubInst( + val m5_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(976.0)) + val m5_s2: DataTypeInstance = AddInst(LitInst(1.0), LitInst(976.0)) + val m5_s3: DataTypeInstance = SubInst(LitInst(1.0), LitInst(976.0)) + + val m5_all: DataTypeInstance = SubInst( NegInst(LitInst(2.0)), // Sub-Left MultInst( // Sub-Right SubInst(LitInst(1.0), LitInst(976.0)), // Mult-Left @@ -26,7 +29,7 @@ object M5 extends Evolution { MultInst(LitInst(1.0), LitInst(976.0)), DivdInst(LitInst(1.0), LitInst(3.0))))) - val tree_m5_all = + val tree_m5_all: Node = Node(Sub.name.hashCode, Seq( Node(Neg.name.hashCode, Seq(Node(Lit.name.hashCode, Seq(Leaf(DoubleInst(2.0)))))), // Sub-Left @@ -53,11 +56,10 @@ object M5 extends Evolution { )) // Mult-Right )) - val m5_s4 = MultInst(MultInst(LitInst(2.0), LitInst(1.0)), + val m5_s4: DataTypeInstance = MultInst(MultInst(LitInst(2.0), LitInst(1.0)), AddInst(LitInst(0.0), LitInst(7.0))) - - val treeSimplified = + val treeSimplified: Node = Node(Mult.name.hashCode, Seq( Node(Lit.name.hashCode, Seq(Leaf(DoubleInst(2.0)))), @@ -84,9 +86,9 @@ object M5 extends Evolution { SameTestCase(m5_s1, m5_s3, expected = true), SameTestCase(m5_all, m5_all, expected = true), - EqualsTestCase(getModel.baseDataType, m5_all, Operation.asTree, InstanceRep(TypeRep.Tree)(tree_m5_all)), + EqualsTestCase(getModel.baseDataType, m5_all, Operation.asTree, InstanceRep(DomainTpeRep.Tree)(tree_m5_all)), EqualsCompositeTestCase(getModel.baseDataType, m5_all, StringInst("(-2.0-((1.0-976.0)*((1.0*976.0)+(1.0/3.0))))"), (PrettyP, Seq.empty)), - EqualsCompositeTestCase(getModel.baseDataType, m5_s4, InstanceRep(TypeRep.Tree)(treeSimplified), (Simplify, Seq.empty), (Operation.asTree, Seq.empty)), + EqualsCompositeTestCase(getModel.baseDataType, m5_s4, InstanceRep(DomainTpeRep.Tree)(treeSimplified), (Simplify, Seq.empty), (Operation.asTree, Seq.empty)), ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M6.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M6.scala index f62b6bd0..baa408fd 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M6.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M6.scala @@ -1,8 +1,11 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.{Tag, TestCase, TypeRep} import org.combinators.ep.domain.{Evolution, GenericModel} -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, Operation, Parameter, PerformanceTestCase, Tag, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions.{DataTypeCase, DomainTpeRep, EqualsTestCase, Operation, Parameter, PerformanceTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Add, AddInst, LitInst} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.M3.{DivdInst, MultInst, NegInst} @@ -10,7 +13,7 @@ import org.combinators.ep.domain.math.M3.{DivdInst, MultInst, NegInst} object M6 extends Evolution { override implicit def getModel:GenericModel = M5.getModel.evolve("m6", Seq.empty, Seq(Equals,Eql) ++ isOps(allTypes)) - lazy val allTypes = M5.getModel.flatten.typeCases + lazy val allTypes: Seq[DataTypeCase] = M5.getModel.flatten.typeCases def isOps(tpeCases:Seq[DataTypeCase]) : Seq[Operation] = { tpeCases.map(tpe => isOp(tpe)) } @@ -27,21 +30,21 @@ object M6 extends Evolution { // that we need to have a way to instantiate a structure that matches the expression // and then use those structure(s) to determine equality. // TODO: HACK -- have to manually change 'equals' to something other than equals - lazy val Equals = Operation("ep_equals", TypeRep.Boolean, Seq(Parameter("other", TypeRep.DataType(M5.getModel.baseDataType)))) + lazy val Equals: Operation = Operation("ep_equals", TypeRep.Boolean, Seq(Parameter("other", DomainTpeRep.DataType(M5.getModel.baseDataType)))) // EQL depends on past IsXXX which you know from ALL PAST evolutions - lazy val Eql = Operation("eql", TypeRep.Boolean, Seq(Parameter("other", TypeRep.DataType(M5.getModel.baseDataType)))) + lazy val Eql: Operation = Operation("eql", TypeRep.Boolean, Seq(Parameter("other", DomainTpeRep.DataType(M5.getModel.baseDataType)))) - val m6_s1 = SubInst(LitInst(1.0), LitInst(73.0)) - val m6_s2 = SubInst(LitInst(1.0), LitInst(73.0)) - val m6_s3 = AddInst(LitInst(5.0), LitInst(3.0)) + val m6_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(73.0)) + val m6_s2: DataTypeInstance = SubInst(LitInst(1.0), LitInst(73.0)) + val m6_s3: DataTypeInstance = AddInst(LitInst(5.0), LitInst(3.0)) - val m6_m1 = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) - val m6_m2 = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(3.0)) - val m6_m3 = NegInst(m6_m1) + val m6_m1: DataTypeInstance = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(4.0)) + val m6_m2: DataTypeInstance = MultInst(DivdInst(LitInst(5.0), LitInst(2.0)), LitInst(3.0)) + val m6_m3: DataTypeInstance = NegInst(m6_m1) - val m6_d3 = DivdInst(LitInst(6.0), LitInst(2.0)) - val m6_d4 = DivdInst(LitInst(8.0), LitInst(2.0)) + val m6_d3: DataTypeInstance = DivdInst(LitInst(6.0), LitInst(2.0)) + val m6_d4: DataTypeInstance = DivdInst(LitInst(8.0), LitInst(2.0)) object EqualsBinaryMethodTestCase { def apply(op:Operation,instance: DataTypeInstance, instance1: DataTypeInstance, result: Boolean): TestCase = { @@ -50,7 +53,7 @@ object M6 extends Evolution { instance, op, InstanceRep(TypeRep.Boolean)(result), - InstanceRep.apply(instance1)(getModel) + DataTypeInstanceRep.apply(instance1)(getModel) ) } } @@ -88,13 +91,13 @@ object M6 extends Evolution { AddInst(LitInst(1.0), LitInst(2.0)), // first, base instance // initial parameter to use when testing equals - Seq(InstanceRep(AddInst(LitInst(1.0), LitInst(2.0)))), + Seq(DataTypeInstanceRep(AddInst(LitInst(1.0), LitInst(2.0)))), // function tells how InstanceRep parameters evolve with each iteration // Seq[InstanceRep] => Seq[InstanceRep] params => params.map(param => param.inst match { - case i: InstanceRep => InstanceRep(DataTypeInstance(Add, Seq(i,i))) + case i: InstanceRep => DataTypeInstanceRep(DataTypeInstance(Add, Seq(i,i))) case _ => param }), diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M7.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M7.scala index 623c4e67..c5b0f608 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M7.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M7.scala @@ -1,23 +1,22 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsCompositeTestCase, Operation, Parameter, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DomainTpeRep, EqualsCompositeTestCase, Operation, Parameter} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.{Evolution, GenericModel} import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst} object M7 extends Evolution { override implicit def getModel:GenericModel = M6.getModel.evolve("m7", Seq.empty, Seq(PowBy)) - // m7:model evolution. - // ------------------- object m7_extensions { val target = "target" } - // add PowBy operation - - lazy val base = TypeRep.DataType(M2.getModel.baseDataType) - lazy val PowBy = Operation("powBy", base, Seq(Parameter("other", base))) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(M2.getModel.baseDataType) + lazy val PowBy: Operation = Operation("powBy", base, Seq(Parameter("other", base))) object PowByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected:InstanceRep): TestCase = { @@ -25,21 +24,21 @@ object M7 extends Evolution { instance, expected, (PowBy, Seq(argument)), (Eval, Seq.empty)) } } - // val m7_1 = SqrtInst(LitInst(25.0)) - val m7_2 = AddInst(LitInst(1.0), LitInst(2.0)) - val m7_3 = AddInst(LitInst(1.0), LitInst(2.0)) - val m7_4 = AddInst(m7_2, m7_3) - val m7_5 = AddInst(LitInst(99.0), LitInst(2.0)) - val m7_6 = AddInst(LitInst(99.0), LitInst(2.0)) - val m7_7 = AddInst(m7_5, m7_6) + val m7_2: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val m7_3: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val m7_4: DataTypeInstance = AddInst(m7_2, m7_3) + + val m7_5: DataTypeInstance = AddInst(LitInst(99.0), LitInst(2.0)) + val m7_6: DataTypeInstance = AddInst(LitInst(99.0), LitInst(2.0)) + val m7_7: DataTypeInstance = AddInst(m7_5, m7_6) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M6) def tests:Seq[TestCase] = Seq( PowByTestCase(AddInst(LitInst(1.0), LitInst(12.0)), - InstanceRep(LitInst(4.0)), DoubleInst(13.0*13.0*13.0*13.0)), + DataTypeInstanceRep(LitInst(4.0)), DoubleInst(13.0*13.0*13.0*13.0)), PowByTestCase(LitInst(12.0), - InstanceRep(LitInst(0.0)), DoubleInst(1)) + DataTypeInstanceRep(LitInst(0.0)), DoubleInst(1)) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M7I2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M7I2.scala index 087ef842..c96edd25 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M7I2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M7I2.scala @@ -1,7 +1,7 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.TestCase import org.combinators.ep.domain.math.systemI.I2 object M7I2 extends Evolution { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M8.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M8.scala index cff2a7be..6fbeac9d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M8.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M8.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsCompositeTestCase, EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsCompositeTestCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} import org.combinators.ep.domain.math.M4.Simplify @@ -10,16 +12,14 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object M8 extends Evolution { override implicit def getModel:GenericModel = M7I2.getModel.evolve("m8", Seq(Inv), M6.isOps(Seq(Inv))) - // M8:model evolution. INV which is opposite of DIV, or 1/DIV - // ------------------- - lazy val Inv = DataTypeCase.binary("Inv")(MathDomain.getModel) + lazy val Inv: DataTypeCase = DataTypeCase.binary("Inv")(MathDomain.getModel) def InvInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Inv, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Inv, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val m8_d1 = InvInst(LitInst(5.0), LitInst(2.0)) - val m8_d2 = InvInst(LitInst(1.0), LitInst(5.0)) + val m8_d1: DataTypeInstance = InvInst(LitInst(5.0), LitInst(2.0)) + val m8_d2: DataTypeInstance = InvInst(LitInst(1.0), LitInst(5.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M7I2) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/M9.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/M9.scala index 7c336581..7bb9fd28 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/M9.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/M9.scala @@ -1,14 +1,16 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.{TestCase, TypeRep} +import org.combinators.ep.domain.abstractions.{EqualsTestCase, Operation} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.{Evolution, GenericModel} import org.combinators.ep.domain.math.M0.{AddInst, LitInst} object M9 extends Evolution { override implicit def getModel:GenericModel = M8.getModel.evolve("m9", Seq.empty, Seq(Height)) - lazy val Height = Operation("height", TypeRep.Int, Seq.empty) + lazy val Height: Operation = Operation("height", TypeRep.Int, Seq.empty) // m9_3 <-- m9_3 has height of 3 // / \ @@ -18,10 +20,10 @@ object M9 extends Evolution { // / \ // m9_0 m9_0 <-- height(s) of 0 // - val m9_0 = LitInst(2.0) - val m9_1 = AddInst(m9_0, m9_0) - val m9_2 = AddInst(m9_0, m9_1) - val m9_3 = AddInst(m9_0, m9_2) + val m9_0: DataTypeInstance = LitInst(2.0) + val m9_1: DataTypeInstance = AddInst(m9_0, m9_0) + val m9_2: DataTypeInstance = AddInst(m9_0, m9_1) + val m9_3: DataTypeInstance = AddInst(m9_0, m9_2) def IntInst(i: scala.Int): InstanceRep = InstanceRep(TypeRep.Int)(i) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/MathDomain.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/MathDomain.scala index a5adc91f..981e46ae 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/MathDomain.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/MathDomain.scala @@ -1,7 +1,7 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.TestCase /** Mathematical Expressions domain as an instance of EP. */ object MathDomain extends Evolution { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/N1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/N1.scala index a06a4fbf..7526dbdf 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/N1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/N1.scala @@ -1,17 +1,18 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst} object N1 extends Evolution { override implicit def getModel:GenericModel = M3.getModel.evolve("n1", Seq.empty, Seq(PowBy)) - // add PowBy operation - - lazy val base = TypeRep.DataType(M2.getModel.baseDataType) - lazy val PowBy = Operation("powBy", base, Seq(Parameter("other", base))) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(M2.getModel.baseDataType) + lazy val PowBy: Operation = Operation("powBy", base, Seq(Parameter("other", base))) object PowByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected: InstanceRep): TestCase = { @@ -20,21 +21,21 @@ object N1 extends Evolution { } } - val n1_2 = AddInst(LitInst(1.0), LitInst(2.0)) - val n1_3 = AddInst(LitInst(1.0), LitInst(2.0)) - val n1_4 = AddInst(n1_2, n1_3) + val n1_2: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val n1_3: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val n1_4: DataTypeInstance = AddInst(n1_2, n1_3) - val n1_5 = AddInst(LitInst(99.0), LitInst(2.0)) - val n1_6 = AddInst(LitInst(99.0), LitInst(2.0)) - val n1_7 = AddInst(n1_5, n1_6) + val n1_5: DataTypeInstance = AddInst(LitInst(99.0), LitInst(2.0)) + val n1_6: DataTypeInstance = AddInst(LitInst(99.0), LitInst(2.0)) + val n1_7: DataTypeInstance = AddInst(n1_5, n1_6) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M3) def tests:Seq[TestCase] = Seq( PowByTestCase(AddInst(LitInst(1.0), LitInst(12.0)), - InstanceRep(LitInst(4.0)), DoubleInst(13.0*13.0*13.0*13.0)), + DataTypeInstanceRep(LitInst(4.0)), DoubleInst(13.0*13.0*13.0*13.0)), PowByTestCase(LitInst(12.0), - InstanceRep(LitInst(0.0)), DoubleInst(1)) - ) // + DataTypeInstanceRep(LitInst(0.0)), DoubleInst(1)) + ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/P1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/P1.scala index 4a8874f0..27e250c3 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/P1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/P1.scala @@ -1,8 +1,10 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.{TestCase, TypeRep} import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.{Attribute, DataTypeCase, EqualsTestCase, Operation, Parameter, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions.{Attribute, DataTypeCase, DomainTpeRep, EqualsTestCase, Operation, Parameter} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} /** @@ -12,36 +14,34 @@ import org.combinators.ep.domain.math.M0.{Eval, LitInst} object P1 extends Evolution { override implicit def getModel:GenericModel = M2.getModel.evolve("p1", Seq(Pi, Rnd, Amortized), Seq(CountBetween, Output, ParamHeight)) - // p1:model evolution. - // ------------------- object independent { - val height:String = "height" - val P = Attribute("P", TypeRep.DataType(MathDomain.getModel.baseDataType)) - val r = Attribute("r", TypeRep.DataType(MathDomain.getModel.baseDataType)) - val n = Attribute("n", TypeRep.DataType(MathDomain.getModel.baseDataType)) - val countBetween:String = "countBetween" - val low:String = "low" - val high:String = "high" + val height: String = "height" + val P: Attribute = Attribute("P", DomainTpeRep.DataType(MathDomain.getModel.baseDataType)) + val r: Attribute = Attribute("r", DomainTpeRep.DataType(MathDomain.getModel.baseDataType)) + val n: Attribute = Attribute("n", DomainTpeRep.DataType(MathDomain.getModel.baseDataType)) + val countBetween: String = "countBetween" + val low: String = "low" + val high: String = "high" } // This Height implementation takes a parameter, into which the initial call passes the value '0' // and then it is passed downwards. - lazy val ParamHeight = Operation(independent.height, TypeRep.Int, Seq(Parameter(independent.height, TypeRep.Int))) - lazy val Output = Operation("output") - lazy val CountBetween = Operation(independent.countBetween, TypeRep.Int, + lazy val ParamHeight: Operation = Operation(independent.height, TypeRep.Int, Seq(Parameter(independent.height, TypeRep.Int))) + lazy val Output: Operation = Operation("output") + lazy val CountBetween: Operation = Operation(independent.countBetween, TypeRep.Int, Seq(Parameter(independent.low, TypeRep.Double), Parameter(independent.high, TypeRep.Double)), ) - lazy val Pi = DataTypeCase.atomic("Pi") - lazy val Rnd = DataTypeCase.atomic("Rnd") - lazy val Amortized = DataTypeCase("Amortized", Seq(independent.P, independent.r, independent.n)) + lazy val Pi: DataTypeCase = DataTypeCase.atomic("Pi") + lazy val Rnd: DataTypeCase = DataTypeCase.atomic("Rnd") + lazy val Amortized: DataTypeCase = DataTypeCase("Amortized", Seq(independent.P, independent.r, independent.n)) def AmortizedInst(P:DataTypeInstance, r:DataTypeInstance, n:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Amortized, Seq(InstanceRep(P), InstanceRep(r), InstanceRep(n))) + DataTypeInstance(Amortized, Seq(DataTypeInstanceRep(P), DataTypeInstanceRep(r), DataTypeInstanceRep(n))) - val p1_a1 = AmortizedInst(LitInst(100000.0), LitInst(0.06), LitInst(360.0)) + val p1_a1: DataTypeInstance = AmortizedInst(LitInst(100000.0), LitInst(0.06), LitInst(360.0)) def tests:Seq[TestCase] = Seq( - EqualsTestCase(getModel.baseDataType, p1_a1, Eval, InstanceRep(LitInst(599.55))) + EqualsTestCase(getModel.baseDataType, p1_a1, Eval, DataTypeInstanceRep(LitInst(599.55))) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/Q1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/Q1.scala index a28dd9c6..2fb8808b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/Q1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/Q1.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.{TestCase, TypeRep} +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, Operation} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -9,16 +11,16 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object Q1 extends Evolution { override implicit def getModel:GenericModel = M3W1.getModel.evolve("q1", Seq(Sqrt), Seq(Operation.asTree, Identifier)) - lazy val Sqrt = DataTypeCase.unary("Sqrt")(MathDomain.getModel) + lazy val Sqrt: DataTypeCase = DataTypeCase.unary("Sqrt")(MathDomain.getModel) - lazy val Identifier = Operation("id", TypeRep.Int) + lazy val Identifier: Operation = Operation("id", TypeRep.Int) def SqrtInst(inner:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Sqrt, Seq(InstanceRep(inner))) + DataTypeInstance(Sqrt, Seq(DataTypeInstanceRep(inner))) // Tests - val q1_d1 = SqrtInst(LitInst(5.0)) - val q1_d2 = SqrtInst(LitInst(16.0)) + val q1_d1: DataTypeInstance = SqrtInst(LitInst(5.0)) + val q1_d2: DataTypeInstance = SqrtInst(LitInst(16.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M3W1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/V1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/V1.scala index de249eda..6efa8999 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/V1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/V1.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsCompositeTestCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -11,20 +13,19 @@ object V1 extends Evolution { // M8:model evolution. INV which is opposite of DIV, or 1/DIV // ------------------- - lazy val Inv = DataTypeCase.binary("Inv")(MathDomain.getModel) + lazy val Inv: DataTypeCase = DataTypeCase.binary("Inv")(MathDomain.getModel) def InvInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Inv, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Inv, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val v1_d1 = InvInst(LitInst(5.0), LitInst(2.0)) - val v1_d2 = InvInst(LitInst(1.0), LitInst(5.0)) + val v1_d1: DataTypeInstance = InvInst(LitInst(5.0), LitInst(2.0)) + val v1_d2: DataTypeInstance = InvInst(LitInst(1.0), LitInst(5.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(C2) def tests: Seq[TestCase] = Seq( EqualsTestCase(getModel.baseDataType, v1_d1, PrettyP, StringInst("(2.0/5.0)")), EqualsTestCase(getModel.baseDataType, v1_d1, Eval, M0.DoubleInst(0.4)), - ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/W1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/W1.scala index 8cf041e2..beb06770 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/W1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/W1.scala @@ -1,24 +1,22 @@ package org.combinators.ep.domain.math /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{DoubleInst, Eval, LitInst} object W1 extends Evolution { override implicit def getModel:GenericModel = M1.getModel.evolve("w1", Seq(Power), Seq.empty) - // w:model evolution. - // ------------------- lazy val Power:DataTypeCase = DataTypeCase.binary("Power")(MathDomain.getModel) def PowerInst(base:DataTypeInstance, exponent:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Power, Seq(InstanceRep(base), InstanceRep(exponent))) + DataTypeInstance(Power, Seq(DataTypeInstanceRep(base), DataTypeInstanceRep(exponent))) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M1) - - // TODO: Model test cases for W1 def tests: Seq[TestCase] = Seq( EqualsTestCase(getModel.baseDataType, PowerInst(LitInst(2.0), LitInst(5.0)), Eval, DoubleInst(32.0)), ) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1.scala index ec162a54..2808c2d5 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1.scala @@ -1,13 +1,15 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} + +import scala.language.postfixOps object A1 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -51,33 +53,10 @@ object A1 { onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case math.A1.Times => mult(atts: _*) + case math.A1.Times => mult(atts*) case _ => ??? } -// case math.systemI.I1.MultBy => -// onRequest.tpeCase match { -// case other@math.A1.Times => -// val lAtt = other.attributes.head -// val rAtt = other.attributes.tail.head -// -// for { -// left <- forApproach.dispatch(SendRequest( -// onRequest.attributes(lAtt), -// math.M2.getModel.baseDataType, -// onRequest.request -// )) -// right <- forApproach.dispatch(SendRequest( -// onRequest.attributes(rAtt), -// math.M2.getModel.baseDataType, -// onRequest.request -// )) -// -// res <- forApproach.instantiate(math.M0.getModel.baseDataType, other, left, right) -// } yield res -// case _ => ??? -// } - case mb@math.systemI.I1.MultBy => // WE CAN OPTIMIZE MultBy with Mult for { res <- forApproach.instantiate(math.M0.getModel.baseDataType, math.A1.Times, onRequest.selfReference, onRequest.request.arguments.head._2) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3.scala index 9f7953ca..e03121ea 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3.scala @@ -1,13 +1,13 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Strings import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.Strings object A1M3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3I2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3I2.scala index fd3425be..de5a024d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3I2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A1M3I2.scala @@ -1,14 +1,14 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Strings +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.ffi.Strings +import AnyParadigm.syntax.forEach object A1M3I2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -38,31 +38,12 @@ object A1M3I2 { (forApproach: AIP[paradigm.type]) (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { - import ffiStrings.stringCapabilities._ import paradigm._ - import methodBodyCapabilities._ assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) - // HACK HACK HACK EMPTY CAN REMOVE - def operate(atts: Seq[syntax.Expression]): Generator[paradigm.MethodBodyContext, syntax.Expression] = - onRequest.request.op match { - case _ => ??? - } + ??? - val result = - for { - atts <- forEach (onRequest.tpeCase.attributes) { att => - forApproach.dispatch(SendRequest( - onRequest.attributes(att), - math.M3.getModel.baseDataType, - onRequest.request - )) - } - res <- operate(atts) - } yield res - - result.map(Some(_)) } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A3.scala index fa4a9359..2000ea28 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/A3.scala @@ -1,20 +1,22 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} + +import scala.language.postfixOps object A3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] - (paradigm: P) - (a1m3i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): + (paradigm: P) + (a1m3i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val a3Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { override val model: GenericModel = math.A3.getModel @@ -27,17 +29,17 @@ object A3 { } yield () } - override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { - if ((potentialRequest.tpeCase == math.A3.Inv) && Set(math.M0.Eval, math.M2.PrettyP, math.systemI.I1.MultBy).contains(potentialRequest.op)) { - Some(Set.empty) - } else { - None + override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { + if ((potentialRequest.tpeCase == math.A3.Inv) && Set(math.M0.Eval, math.M2.PrettyP, math.systemI.I1.MultBy).contains(potentialRequest.op)) { + Some(Set.empty) + } else { + None + } } - } def logic - (forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (forApproach: AIP[paradigm.type]) + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import ffiStrings.stringCapabilities._ import ffiArithmetic.arithmeticCapabilities._ @@ -51,7 +53,7 @@ object A3 { onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case math.A3.Inv => div(Seq(atts.tail.head, atts.head): _*) // FLIP + case math.A3.Inv => div(Seq(atts.tail.head, atts.head)*) // FLIP case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/C2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/C2.scala index d0207c3d..332c33bc 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/C2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/C2.scala @@ -1,19 +1,17 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.{Command, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Lists, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi._ -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} -import scala.collection.immutable.Set - -// Code for M4. Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be -// used in an uniform way. +// Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be used in an uniform way. sealed class C2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = (paradigm.syntax.Expression, @@ -28,9 +26,7 @@ sealed class C2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiLists: Lists.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], - returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], - ifThenElse: IfThenElseCommand + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type] ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val c2Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { override val model: GenericModel = math.C2.getModel @@ -137,8 +133,7 @@ object C2 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (q1Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiLists: Lists.WithBase[paradigm.MethodBodyContext, paradigm.type], @@ -146,44 +141,21 @@ object C2 { EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ val mkImpl = new C2[paradigm.type, AIP, Expression](paradigm) - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - res <- functionalControl.functionalCapabilities.ifThenElse(cond, ifBlock, ifElseBlocks, elseBlock) - } yield Some(res) - - mkImpl(q1Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiLists, ffiEquality, expGen => expGen, ite) + mkImpl(q1Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiLists, ffiEquality) } def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (q1Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiLists: Lists.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { - import paradigm.syntax._ - import paradigm.methodBodyCapabilities._ - import imperativeControl.imperativeCapabilities._ - val mkImpl = new C2[paradigm.type, AIP, Unit](paradigm) - val returnInIf: Generator[paradigm.MethodBodyContext, Expression] => Generator[paradigm.MethodBodyContext, Unit] = - expGen => - for { - resultExp <- expGen - resultStmt <- returnStmt(resultExp) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - resultStmt <- ifThenElse(cond, ifBlock, ifElseBlocks, Some(elseBlock)) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None + val mkImpl = new C2[paradigm.type, AIP, Unit](paradigm) - mkImpl(q1Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiLists, ffiEquality, returnInIf, ite) + mkImpl(q1Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiLists, ffiEquality) } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/I2M3I1N1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/I2M3I1N1.scala index 50b41bbe..c2d212f1 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/I2M3I1N1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/I2M3I1N1.scala @@ -1,12 +1,12 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Booleans, Equality, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Booleans, Equality, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} sealed class I2M3I1N1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]](val paradigm: P) { @@ -87,7 +87,6 @@ object I2M3I1N1 { ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { - import paradigm.syntax._ val mkImpl = new I2M3I1N1[paradigm.type, AIP](paradigm) mkImpl(i2Provider,m3i1Provider,n1Provider)(ffiBoolean, ffiEquality, ffiStrings) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M0.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M0.scala index 775343bd..2dbfd133 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M0.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M0.scala @@ -1,12 +1,13 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.Command +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} -import org.combinators.ep.domain.math -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import org.combinators.ep.domain.{GenericModel, math} /** * Truly language independent abstractions. Since we are in the mathematical domain, the @@ -30,7 +31,7 @@ object M0 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M0.getModel + override val model: GenericModel = math.M0.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -46,10 +47,6 @@ object M0 { None } } -// -// def applicable (forApproach: AIP[paradigm.type], onRequest:PotentialRequest): Boolean = { -// (onRequest.op == math.M0.Eval) && Set(math.M0.Add, math.M0.Lit).contains(onRequest.tpeCase) -// } override def logic (forApproach: AIP[paradigm.type ]) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M1.scala index 19143bb7..60a0af50 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M1.scala @@ -1,12 +1,12 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.Arithmetic import EvolutionImplementationProvider._ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic import org.combinators.ep.domain.abstractions.Operation object M1 { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2.scala index 69f3368b..84ec62d6 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2.scala @@ -1,13 +1,13 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} object M2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2_ABS.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2_ABS.scala index d1fd0791..cf727b46 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2_ABS.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M2_ABS.scala @@ -1,20 +1,17 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.{Command, InstanceRep, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} -import org.combinators.ep.generator.paradigm.control.Functional +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} - -// Code for M2_ABS. Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be -// used in an uniform way. +// Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be used in an uniform way. sealed class M2_ABS[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = (paradigm.syntax.Expression, @@ -126,7 +123,7 @@ object M2_ABS { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m2Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { @@ -144,7 +141,7 @@ object M2_ABS { def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m2Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3.scala index df627903..c093a70b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3.scala @@ -1,14 +1,16 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.TypeRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} + +import scala.language.postfixOps object M3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -58,8 +60,8 @@ object M3 { onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case math.M3.Divd => div(atts: _*) - case math.M3.Mult => mult(atts: _*) + case math.M3.Divd => div(atts*) + case math.M3.Mult => mult(atts*) case math.M3.Neg => for { minusOne <- reify(TypeRep.Double, -1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3I1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3I1.scala index 85019c4d..7ae692c6 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3I1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3I1.scala @@ -1,13 +1,12 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Booleans, Equality, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Booleans, Equality, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} sealed class M3I1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]](val paradigm: P) { @@ -62,29 +61,7 @@ sealed class M3I1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat case _ => ??? } -// def operate(): Generator[paradigm.MethodBodyContext, syntax.Expression] = -// onRequest.request.op match { -// case mb@math.systemI.I1.MultBy => // take advantage of Mult data type -// for { -// res <- forApproach.instantiate(math.M0.getModel.baseDataType, math.M3.Mult, onRequest.selfReference, onRequest.request.arguments.head._2) -// } yield res -// -// case _ => ??? -// } -// -// val result = -// for { -// atts <- forEach (onRequest.tpeCase.attributes) { att => -// forApproach.dispatch(SendRequest( -// onRequest.attributes(att), -// math.M3.getModel.baseDataType, -// onRequest.request -// )) -// } -// res <- operate() -// } yield res -// -// result.map(Some(_)) + } } @@ -98,12 +75,10 @@ object M3I1 { (paradigm: P) (m3Provider: EvolutionImplementationProvider[AIP[paradigm.type]], i1Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + (ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { - import paradigm.syntax._ val mkImpl = new M3I1[paradigm.type, AIP](paradigm) mkImpl(m3Provider,i1Provider)(ffiBoolean, ffiEquality, ffiStrings) @@ -113,8 +88,7 @@ object M3I1 { (paradigm: P) (m3Provider: EvolutionImplementationProvider[AIP[paradigm.type]], i1Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + (ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3W1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3W1.scala index 327bc80c..d0a0058c 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3W1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M3W1.scala @@ -1,14 +1,13 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.{GenericModel, abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance -import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} /** Upon merging M3 and W1 there is a need for MultByx(Divd, Mult, Neg) as well as a need for @@ -67,7 +66,7 @@ sealed class M3W1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) val result = onRequest.tpeCase match { - case power@math.W1.Power => { + case power@math.W1.Power => onRequest.request.op match { case pp@math.M2.PrettyP => @@ -88,7 +87,6 @@ sealed class M3W1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat case _ => ??? } - } case _ => ??? } result.map(Some(_)) @@ -106,53 +104,29 @@ object M3W1 { (paradigm: P) (m3Provider: EvolutionImplementationProvider[AIP[paradigm.type]], w1Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ val mkImpl = new M3W1[paradigm.type, AIP, Expression](paradigm) - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - res <- functionalControl.functionalCapabilities.ifThenElse(cond, ifBlock, ifElseBlocks, elseBlock) - } yield Some(res) - mkImpl(m3Provider,w1Provider)(ffiArithmetic, ffiBoolean, ffiEquality, ffiStrings) // , expGen => expGen, ite) + mkImpl(m3Provider,w1Provider)(ffiArithmetic, ffiBoolean, ffiEquality, ffiStrings) } def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m3Provider: EvolutionImplementationProvider[AIP[paradigm.type]], w1Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { - import paradigm.syntax._ - import paradigm.methodBodyCapabilities._ - import imperativeControl.imperativeCapabilities._ val mkImpl = new M3W1[paradigm.type, AIP, Unit](paradigm) - val returnInIf: Generator[paradigm.MethodBodyContext, Expression] => Generator[paradigm.MethodBodyContext, Unit] = - expGen => - for { - resultExp <- expGen - resultStmt <- returnStmt(resultExp) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - resultStmt <- ifThenElse(cond, ifBlock, ifElseBlocks, Some(elseBlock)) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - mkImpl(m3Provider,w1Provider)(ffiArithmetic, ffiBoolean, ffiEquality, ffiStrings) // , returnInIf, ite) + mkImpl(m3Provider,w1Provider)(ffiArithmetic, ffiBoolean, ffiEquality, ffiStrings) } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M4.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M4.scala index 507de26a..37e7d0bb 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M4.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M4.scala @@ -1,15 +1,15 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.{abstractions, math} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.cogen.{Command, InstanceRep, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Lists, Strings} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} +import org.combinators.ep.domain.{GenericModel, abstractions, math} +import org.combinators.cogen.Command.Generator +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Lists, Strings} // Code for M4. Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be // used in an uniform way. @@ -32,7 +32,7 @@ sealed class M4[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio ifThenElse: IfThenElseCommand ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val m4Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M4.getModel + override val model: GenericModel = math.M4.getModel override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { val cases = math.M4.getModel.flatten.typeCases @@ -119,7 +119,7 @@ sealed class M4[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio import ffiBoolean.booleanCapabilities._ def evalChildren(tpe:DataTypeCase, atts: Map[abstractions.Attribute,Expression]): Generator[MethodBodyContext, List[Expression]] = - forEach (atts.keys.toSeq) { att:abstractions.Attribute => { + forEach (atts.keys.toSeq) { (att:abstractions.Attribute) => { val expr:Expression = atts(att) forApproach.dispatch( SendRequest( @@ -300,7 +300,7 @@ object M4 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m3Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], @@ -321,7 +321,7 @@ object M4 { def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m3Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M5.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M5.scala index cc008d0c..4f4352cd 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M5.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M5.scala @@ -1,13 +1,15 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Attribute, DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic +import org.combinators.ep.generator.paradigm.ffi.Trees +import org.combinators.ep.domain.abstractions.{Attribute, DomainTpeRep, Operation} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Trees} object M5 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -17,7 +19,7 @@ object M5 { ffiTrees: Trees.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val treeIdProvider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M5.getModel + override val model: GenericModel = math.M5.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -41,7 +43,6 @@ object M5 { } } - /** Can handle any AsTree or Identifier operations. */ override def genericLogic (forApproach: AIP[paradigm.type]) @@ -56,7 +57,7 @@ object M5 { case op if op == Operation.asTree => for { children <- forEach (onRequest.attributes.toSeq) { - case (att@Attribute(_, TypeRep.DataType(dt)), attExp) => + case (att@Attribute(_, DomainTpeRep.DataType(dt)), attExp) => forApproach.dispatch( SendRequest( attExp, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M6.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M6.scala index d46e771d..6b8914e3 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M6.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M6.scala @@ -1,14 +1,16 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.ffi.{Booleans, Equality} +import AnyParadigm.syntax.forEach +import org.combinators.cogen.Command +import org.combinators.cogen.paradigm.ffi.{Booleans, Equality} +import org.combinators.ep.domain.extensions._ // needed for isModelBase object M6 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -19,7 +21,7 @@ object M6 { ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val equalsProvider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M6.getModel + override val model: GenericModel = math.M6.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -81,14 +83,14 @@ object M6 { Request(Operation.asTree, Map.empty) ) ) - treeTpe <- toTargetLanguageType(TypeRep.Tree) + treeTpe <- toTargetLanguageType(DomainTpeRep.Tree) eq <- areEqual(treeTpe, selfTree, otherTree) } yield Some(eq) // default Boolean isAdd(Exp left, Exp right) { // return left.eql(getLeft()) && right.eql(getRight()); // } - case op if op == math.M6.isOp(onRequest.tpeCase) => { + case op if op == math.M6.isOp(onRequest.tpeCase) => import ffiBooleans.booleanCapabilities._ for { res <- forEach(onRequest.attributes.toSeq) { att => { @@ -112,16 +114,15 @@ object M6 { // now construct X && y && z conjunction <- if (res.length == 1) { Command.lift[MethodBodyContext,paradigm.syntax.Expression](res.head) } else { and(res) } } yield Some(conjunction) - } - // need to know when isOp is not in the onRequest Type (to handle return false; default implementation) + // need to know when isOp is not in the onRequest Type (to handle return false; default implementation) // because then we can return FALSE - case op if op != math.M6.isOp(onRequest.tpeCase) && op.tags.contains(math.M6.IsOp) => { + case op if op != math.M6.isOp(onRequest.tpeCase) && op.tags.contains(math.M6.IsOp) => import ffiBooleans.booleanCapabilities._ for { booleanFalse <- falseExp } yield Some(booleanFalse) - } + case _ => m5Provider.genericLogic(forApproach)(onRequest) } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7.scala index 08bbbb99..b0422ab3 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{Operation, Parameter} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} object M7 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -19,10 +20,10 @@ object M7 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper:Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper:control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val equalsProvider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M7.getModel + override val model: GenericModel = math.M7.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7I2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7I2.scala index a5acb33d..b65b3a65 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7I2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7I2.scala @@ -1,21 +1,22 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.{abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} +import org.combinators.ep.domain.{GenericModel, abstractions, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} /** Upon merging M7 and I2 there is a need for MultByx(Divd, Mult, Neg) as well as a need for - * (Collect,Simplify,Id,AsTree,Equals,PowBy)xPower - * - * These all have to be captured here... - */ + * (Collect,Simplify,Id,AsTree,Equals,PowBy)xPower + * + * These all have to be captured here... + */ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = @@ -27,15 +28,15 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (m7Provider: EvolutionImplementationProvider[AIP[paradigm.type]],i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], - returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], - ifThenElse: IfThenElseCommand): + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], + returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], + ifThenElse: IfThenElseCommand): EvolutionImplementationProvider[AIP[paradigm.type]] = { val m7i2Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M7I2.getModel + override val model: GenericModel = math.M7I2.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -69,11 +70,11 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat case (_, _) => None } } - + // Simplify of Power -- if exponent is 1, then ignore! If exponent is 0, turn to 1; if exponent is -1, turn to DivD private def simplifyLogic(forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[forApproach.paradigm.MethodBodyContext, Option[forApproach.paradigm.syntax.Expression]] = { import paradigm._ import methodBodyCapabilities._ @@ -82,7 +83,7 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat import ffiEquality.equalityCapabilities._ def evalChildren(tpe:DataTypeCase, atts: Map[abstractions.Attribute,Expression]): Generator[MethodBodyContext, List[Expression]] = - forEach (atts.keys.toSeq) { att:abstractions.Attribute => { + forEach (atts.keys.toSeq) { (att:abstractions.Attribute) => { val expr:Expression = atts(att) forApproach.dispatch( SendRequest( @@ -104,15 +105,15 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } def simplifyOp( - atts:Seq[abstractions.Attribute], - attExprs: Seq[Expression], - vals: Generator[MethodBodyContext, List[Expression]], - doubleTy: Type, - zero: Expression, - one: Expression, - zeroLit: Generator[MethodBodyContext, Expression], - oneLit: Generator[MethodBodyContext, Expression] - ): Generator[MethodBodyContext, Option[Expression]] = { + atts:Seq[abstractions.Attribute], + attExprs: Seq[Expression], + vals: Generator[MethodBodyContext, List[Expression]], + doubleTy: Type, + zero: Expression, + one: Expression, + zeroLit: Generator[MethodBodyContext, Expression], + oneLit: Generator[MethodBodyContext, Expression] + ): Generator[MethodBodyContext, Option[Expression]] = { onRequest.tpeCase match { case math.systemI.I2.Power => vals.flatMap { case List(leftVal, rightVal) => @@ -151,9 +152,9 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } // should be no need to define genericLogic since (by default) it will go through the chain of past providers... - override def genericLogic + override def genericLogic (forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[forApproach.paradigm.MethodBodyContext, Option[forApproach.paradigm.syntax.Expression]] = { try { m7Provider.genericLogic(forApproach)(onRequest) @@ -164,7 +165,7 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat def logic (forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import paradigm._ import methodBodyCapabilities._ @@ -184,15 +185,13 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat case math.M4.Collect => m7Provider.genericLogic(forApproach)(onRequest) case mb@math.systemI.I1.MultBy => // WE CAN OPTIMIZE MultBy with Mult - for { - res <- forApproach.instantiate(math.M0.getModel.baseDataType, math.M3.Mult, onRequest.selfReference, onRequest.request.arguments.head._2) - } yield Some(res) + for { + res <- forApproach.instantiate(math.M0.getModel.baseDataType, math.M3.Mult, onRequest.selfReference, onRequest.request.arguments.head._2) + } yield Some(res) case p@math.M7.PowBy => // on Power - // must handle Power dataType. HERE WE CAN OPTIMIZED. - val atts = onRequest.attributes.keys.toSeq - val attExprs = onRequest.attributes.values.toSeq - for { + // must handle Power dataType. HERE WE CAN OPTIMIZED. + for { res <- forApproach.instantiate(math.M0.getModel.baseDataType, math.systemI.I2.Power, onRequest.selfReference, onRequest.request.arguments.head._2) } yield Some(res) } @@ -207,13 +206,13 @@ sealed class M7I2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat object M7I2 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] - (paradigm: P) - (m7Provider: EvolutionImplementationProvider[AIP[paradigm.type]], - i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): + (paradigm: P) + (m7Provider: EvolutionImplementationProvider[AIP[paradigm.type]], + i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ val mkImpl = new M7I2[paradigm.type, AIP, Expression](paradigm) @@ -227,13 +226,13 @@ object M7I2 { } def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] - (paradigm: P) - (m7Provider: EvolutionImplementationProvider[AIP[paradigm.type]], - i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): + (paradigm: P) + (m7Provider: EvolutionImplementationProvider[AIP[paradigm.type]], + i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ import paradigm.methodBodyCapabilities._ diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7funct.scala index eddeaf12..3578b920 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M7funct.scala @@ -1,15 +1,14 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.cogen.paradigm.{AnyParadigm, Functional, control} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation, Parameter} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.Functional -import org.combinators.ep.generator.paradigm.control -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic, Strings, Equality} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object M7funct { @@ -25,7 +24,7 @@ object M7funct { ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val m7Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M7.getModel + override val model: GenericModel = math.M7.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -104,7 +103,7 @@ object M7funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) expName <- freshName(forApproach.names.mangle("exponentValue")) expType <- toTargetLanguageType(TypeRep.Double) @@ -117,7 +116,7 @@ object M7funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - powByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + powByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) powByRecName <- freshName(forApproach.names.mangle("powByRec")) powByRecArg <- freshName(forApproach.names.mangle("exponentValue")) finalResult <- declareRecursiveVariable(powByRecName, powByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M8.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M8.scala index a0ba8674..6cc1f37a 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M8.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M8.scala @@ -1,19 +1,18 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math.systemI.I1 -import org.combinators.ep.domain.{abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} +import org.combinators.ep.domain.{GenericModel, abstractions, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} -// Code for M8. Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be -// used in an uniform way. +// Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be used in an uniform way. sealed class M8[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = @@ -33,7 +32,7 @@ sealed class M8[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio ifThenElse: IfThenElseCommand ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val m8Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M8.getModel + override val model: GenericModel = math.M8.getModel override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { val cases = math.M8.getModel.flatten.typeCases @@ -75,7 +74,7 @@ sealed class M8[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio import ffiBoolean.booleanCapabilities._ def evalChildren(tpe:DataTypeCase, atts: Map[abstractions.Attribute,Expression]): Generator[MethodBodyContext, List[Expression]] = - forEach (atts.keys.toSeq) { att:abstractions.Attribute => { + forEach (atts.keys.toSeq) { (att:abstractions.Attribute) => { val expr:Expression = atts(att) forApproach.dispatch( SendRequest( @@ -242,7 +241,7 @@ object M8 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m7i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], @@ -262,7 +261,7 @@ object M8 { def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m7i2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9.scala index 307e5f06..99a62cfc 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.{abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic} object M9 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -17,10 +18,10 @@ object M9 { (m8Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiImper:Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper:control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val m9Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M9.getModel + override val model: GenericModel = math.M9.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -59,7 +60,7 @@ object M9 { maxName <- freshName(forApproach.names.mangle("max")) maxDecl <- ffiImper.imperativeCapabilities.declareVar(maxName, intType, Some(zero)) - _ <- forEach(onRequest.attributes.toSeq) { case (att, expr) => { + _ <- forEach(onRequest.attributes.toSeq) { case (att, expr) => for { attName <- freshName(forApproach.names.mangle(att.name)) exprVal <- forApproach.dispatch( @@ -82,7 +83,6 @@ object M9 { _ <- addBlockDefinitions(Seq(ifStmt)) } yield () } - } resExpr <- ffiArithmetic.arithmeticCapabilities.add(maxDecl, one) } yield Some(resExpr) @@ -96,8 +96,6 @@ object M9 { (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { import paradigm._ - import AnyParadigm.syntax._ - import methodBodyCapabilities._ assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9funct.scala index acf88d37..7aab7538 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/M9funct.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.{abstractions, math} -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance -import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.control.{ConstructorPattern, Imperative} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} +import org.combinators.cogen.paradigm.control object M9funct { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -19,7 +20,7 @@ object M9funct { ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val m9Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.M9.getModel + override val model: GenericModel = math.M9.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1.scala index 480696a4..ea6ad126 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1.scala @@ -1,14 +1,15 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{Operation, Parameter} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object N1 { @@ -19,10 +20,10 @@ object N1 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper:Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper:control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val n1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.N1.getModel + override val model: GenericModel = math.N1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1funct.scala index f111a20b..6ffc72bb 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/N1funct.scala @@ -1,14 +1,15 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AnyParadigm, Functional} +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation, Parameter} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.cogen.paradigm.control import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object N1funct { @@ -24,7 +25,7 @@ object N1funct { ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val n1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.N1.getModel + override val model: GenericModel = math.N1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -102,7 +103,7 @@ object N1funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) expName <- freshName(forApproach.names.mangle("exponentValue")) expType <- toTargetLanguageType(TypeRep.Double) @@ -115,7 +116,7 @@ object N1funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - powByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + powByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) powByRecName <- freshName(forApproach.names.mangle("powByRec")) powByRecArg <- freshName(forApproach.names.mangle("exponentValue")) finalResult <- declareRecursiveVariable(powByRecName, powByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/Q1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/Q1.scala index edacbaa9..cf41042f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/Q1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/Q1.scala @@ -1,12 +1,14 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Attribute, DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} +import org.combinators.ep.generator.paradigm.ffi.Trees +import org.combinators.ep.domain.abstractions.{Attribute, DomainTpeRep, Operation} +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic, Strings, Trees} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object Q1 { @@ -19,7 +21,7 @@ object Q1 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val q1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.Q1.getModel + override val model: GenericModel = math.Q1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -30,22 +32,6 @@ object Q1 { } yield () } - /** AsTree depends upon Identifier. */ -// override def dependencies(op:Operation, dt:DataTypeCase) : Option[Set[Operation]] = { -// if (op == Operation.asTree) { -// Some(Set(math.Q1.Identifier)) -// } else { -// None -// } -// } -// -// def applicable -// (forApproach: AIP[paradigm.type], potentialRequest:PotentialRequest): Boolean = { -// (Set(math.Q1.Identifier, Operation.asTree).contains(potentialRequest.op) && -// Set(math.M3.Divd,math.M3.Mult, math.M3.Neg,math.M1.Sub,math.M0.Add,math.M0.Lit,math.W1.Power).contains(potentialRequest.tpeCase)) || -// (Set(math.Q1.Sqrt).contains(potentialRequest.tpeCase) && Set(math.M2.PrettyP,math.M0.Eval,math.Q1.Identifier,Operation.asTree).contains(potentialRequest.op)) -// } - override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { val cases = math.Q1.getModel.flatten.typeCases (potentialRequest.op, potentialRequest.tpeCase) match { @@ -71,7 +57,7 @@ object Q1 { case op if op == Operation.asTree => for { children <- forEach (onRequest.attributes.toSeq) { - case (att@Attribute(_, TypeRep.DataType(dt)), attExp) => + case (att@Attribute(_, DomainTpeRep.DataType(dt)), attExp) => forApproach.dispatch( SendRequest( attExp, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/V1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/V1.scala index aac56f29..674e2172 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/V1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/V1.scala @@ -1,17 +1,15 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.{abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance -import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} -// Code for V1. Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be -// used in an uniform way. sealed class V1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = @@ -26,12 +24,10 @@ sealed class V1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], - returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], - ifThenElse: IfThenElseCommand + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type] ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val v1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.V1.getModel + override val model: GenericModel = math.V1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -43,11 +39,6 @@ sealed class V1[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio } yield () } -// def applicable(forApproach: AIP[paradigm.type], potentialRequest:PotentialRequest): Boolean = { -// Set(math.C2.Collect,math.M2.PrettyP,math.M0.Eval,math.Q1.Identifier,Operation.asTree).contains(potentialRequest.op) && -// Set(math.V1.Inv).contains(potentialRequest.tpeCase) -// } - // adds Inv data Type override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { (potentialRequest.op, potentialRequest.tpeCase) match { @@ -135,51 +126,27 @@ object V1 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (c2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ val mkImpl = new V1[paradigm.type, AIP, Expression](paradigm) - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - res <- functionalControl.functionalCapabilities.ifThenElse(cond, ifBlock, ifElseBlocks, elseBlock) - } yield Some(res) - mkImpl(c2Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiEquality, expGen => expGen, ite) + mkImpl(c2Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiEquality) } def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (c2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { - import paradigm.syntax._ - import paradigm.methodBodyCapabilities._ - import imperativeControl.imperativeCapabilities._ val mkImpl = new V1[paradigm.type, AIP, Unit](paradigm) - val returnInIf: Generator[paradigm.MethodBodyContext, Expression] => Generator[paradigm.MethodBodyContext, Unit] = - expGen => - for { - resultExp <- expGen - resultStmt <- returnStmt(resultExp) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - resultStmt <- ifThenElse(cond, ifBlock, ifElseBlocks, Some(elseBlock)) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - mkImpl(c2Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiEquality, returnInIf, ite) + mkImpl(c2Provider)(ffiArithmetic, ffiBoolean, ffiStrings, ffiEquality) } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/W1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/W1.scala index c07ee880..70c292ac 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/W1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/W1.scala @@ -1,12 +1,12 @@ package org.combinators.ep.domain.math.eips /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object W1 { @@ -18,7 +18,7 @@ object W1 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val w1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.W1.getModel + override val model: GenericModel = math.W1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -52,15 +52,12 @@ object W1 { (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { - import ffiArithmetic.arithmeticCapabilities._ import ffiRealArithmetic.realArithmeticCapabilities._ - import ffiStrings.stringCapabilities._ import paradigm._ - import methodBodyCapabilities._ assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) val result = onRequest.tpeCase match { - case power@math.W1.Power => { + case power@math.W1.Power => onRequest.request.op match { case eval@math.M0.Eval => for { @@ -79,7 +76,6 @@ object W1 { case _ => ??? } - } case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1.scala index d1df10d4..0736192d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips.systemD /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemD -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object D1 { @@ -20,10 +21,10 @@ object D1 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val d1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemD.D1.getModel + override val model: GenericModel = math.systemD.D1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1D2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1D2.scala index 84c18205..14d65a1c 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1D2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1D2.scala @@ -1,14 +1,12 @@ package org.combinators.ep.domain.math.eips.systemD /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm import org.combinators.ep.domain.abstractions.Operation -import org.combinators.ep.domain.math +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemD -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} sealed class D1D2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { @@ -21,16 +19,11 @@ sealed class D1D2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] - (d1Provider: EvolutionImplementationProvider[AIP[paradigm.type]],d2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], - returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], - ifThenElse: IfThenElseCommand): + (d1Provider: EvolutionImplementationProvider[AIP[paradigm.type]],d2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val d1d2_provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = systemD.D1D2.getModel + override val model: GenericModel = systemD.D1D2.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -39,7 +32,6 @@ sealed class D1D2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } yield () } - override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { if (Set(math.systemD.D1.MultBy).contains(potentialRequest.op) && Set(math.systemD.D2.Mult, math.M1.Sub, math.M0.Add, math.M0.Lit).contains(potentialRequest.tpeCase)) { Some(Set.empty) @@ -75,56 +67,25 @@ sealed class D1D2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } } - object D1D2 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (d1Provider: EvolutionImplementationProvider[AIP[paradigm.type]], - d2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): + d2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ val mkImpl = new D1D2[paradigm.type, AIP, Expression](paradigm) - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - res <- functionalControl.functionalCapabilities.ifThenElse(cond, ifBlock, ifElseBlocks, elseBlock) - } yield Some(res) - mkImpl(d1Provider,d2Provider)(ffiArithmetic, ffiBoolean, ffiEquality, expGen => expGen, ite) + mkImpl(d1Provider,d2Provider) } def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (d1Provider: EvolutionImplementationProvider[AIP[paradigm.type]], - d2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): + d2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]): EvolutionImplementationProvider[AIP[paradigm.type]] = { - import imperativeControl.imperativeCapabilities._ - import paradigm.methodBodyCapabilities._ - import paradigm.syntax._ val mkImpl = new D1D2[paradigm.type, AIP, Unit](paradigm) - val returnInIf: Generator[paradigm.MethodBodyContext, Expression] => Generator[paradigm.MethodBodyContext, Unit] = - expGen => - for { - resultExp <- expGen - resultStmt <- returnStmt(resultExp) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - - val ite: mkImpl.IfThenElseCommand = - (cond, ifBlock, ifElseBlocks, elseBlock) => - for { - resultStmt <- ifThenElse(cond, ifBlock, ifElseBlocks, Some(elseBlock)) - _ <- addBlockDefinitions(Seq(resultStmt)) - } yield None - mkImpl(d1Provider,d2Provider)(ffiArithmetic, ffiBoolean, ffiEquality, returnInIf, ite) + mkImpl(d1Provider,d2Provider) } } \ No newline at end of file diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1funct.scala index 604a7491..04a5a104 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D1funct.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips.systemD /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation} +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemD -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, control} -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object D1funct { @@ -23,7 +24,7 @@ object D1funct { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type] ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val d1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemD.D1.getModel + override val model: GenericModel = math.systemD.D1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -98,7 +99,7 @@ object D1funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) multName <- freshName(forApproach.names.mangle("multiplier")) multType <- toTargetLanguageType(TypeRep.Double) @@ -111,7 +112,7 @@ object D1funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) multByRecName <- freshName(forApproach.names.mangle("multByRec")) multByRecArg <- freshName(forApproach.names.mangle("multiplier")) finalResult <- declareRecursiveVariable(multByRecName, multByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D2.scala index 4c7d8460..4b5f4271 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D2.scala @@ -1,24 +1,25 @@ package org.combinators.ep.domain.math.eips.systemD /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic import org.combinators.ep.domain.abstractions.Operation -import org.combinators.ep.domain.math +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemD -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object D2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (m1Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val d2Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemD.D2.getModel + override val model:GenericModel = math.systemD.D2.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -26,7 +27,6 @@ object D2 { } yield () } - override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { if (Set(math.M0.Eval).contains(potentialRequest.op) && Set(systemD.D2.Mult).contains(potentialRequest.tpeCase)) { Some(Set.empty) @@ -54,7 +54,7 @@ object D2 { onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case systemD.D2.Mult => mult(atts: _*) + case systemD.D2.Mult => mult(atts*) case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D3.scala index 2601873f..76dd183d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemD/D3.scala @@ -1,13 +1,13 @@ package org.combinators.ep.domain.math.eips.systemD /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation -import org.combinators.ep.domain.math +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemD -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object D3 { @@ -18,7 +18,7 @@ object D3 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val d3Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemD.D3.getModel + override val model: GenericModel = math.systemD.D3.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1.scala index 595ac957..b2b206c3 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips.systemI /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemI -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object I1 { @@ -20,10 +21,10 @@ object I1 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val i1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemI.I1.getModel + override val model: GenericModel = math.systemI.I1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1funct.scala index 613096e4..9f60691e 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I1funct.scala @@ -1,14 +1,16 @@ package org.combinators.ep.domain.math.eips.systemI /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation} +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemI -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.cogen.paradigm.control import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object I1funct { @@ -22,7 +24,7 @@ object I1funct { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type] ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val i1Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemI.I1.getModel + override val model: GenericModel = math.systemI.I1.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -98,7 +100,7 @@ object I1funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) multName <- freshName(forApproach.names.mangle("multiplier")) multType <- toTargetLanguageType(TypeRep.Double) @@ -111,7 +113,7 @@ object I1funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) multByRecName <- freshName(forApproach.names.mangle("multByRec")) multByRecArg <- freshName(forApproach.names.mangle("multiplier")) finalResult <- declareRecursiveVariable(multByRecName, multByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I2.scala index 32fb35d9..7b3256a4 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemI/I2.scala @@ -1,15 +1,15 @@ package org.combinators.ep.domain.math.eips.systemI /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.domain.math -import org.combinators.ep.domain.math.{eips, systemI} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.ep.domain.math.systemI +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object I2 { @@ -21,7 +21,7 @@ object I2 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val i2Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemI.I2.getModel + override val model: GenericModel = math.systemI.I2.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -63,7 +63,7 @@ object I2 { assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) val result = onRequest.tpeCase match { - case power@systemI.I2.Power => { + case power@systemI.I2.Power => onRequest.request.op match { case eval@math.M0.Eval => for { @@ -128,7 +128,6 @@ object I2 { case _ => ??? } - } case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1.scala index a9b252b7..7ae49daa 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1.scala @@ -1,14 +1,15 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J1 { @@ -19,7 +20,7 @@ object J1 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val j1Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { override val model: GenericModel = math.systemJ.J1.getModel diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1funct.scala index 8f8cb808..6d8c02fd 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J1funct.scala @@ -1,15 +1,15 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation} import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.domain.math.systemJ -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, control} -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J1funct { @@ -101,7 +101,7 @@ object J1funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) multName <- freshName(forApproach.names.mangle("multiplier")) multType <- toTargetLanguageType(TypeRep.Double) @@ -114,7 +114,7 @@ object J1funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) multByRecName <- freshName(forApproach.names.mangle("multByRec")) multByRecArg <- freshName(forApproach.names.mangle("multiplier")) finalResult <- declareRecursiveVariable(multByRecName, multByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J2.scala index 800049d5..df8bc60a 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J2.scala @@ -1,15 +1,17 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.domain.math.systemJ -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality} -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import AnyParadigm.syntax.forEach +import org.combinators.cogen.Command +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} + +import org.combinators.ep.domain.extensions._ // needed for isModelBase object J2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -78,7 +80,7 @@ object J2 { // default Boolean isAdd(Exp left, Exp right) { // return left.eql(getLeft()) && right.eql(getRight()); // } - case op if op == math.systemJ.J2.isOp(onRequest.tpeCase) => { + case op if op == math.systemJ.J2.isOp(onRequest.tpeCase) => import ffiBoolean.booleanCapabilities._ for { res <- forEach(onRequest.attributes.toSeq) { att => { @@ -107,16 +109,14 @@ object J2 { and(res) } } yield Some(conjunction) - } // need to know when isOp is not in the onRequest Type (to handle return false; default implementation) // because then we can return FALSE - case op if op != math.systemJ.J2.isOp(onRequest.tpeCase) && op.tags.contains(math.systemJ.J2.IsOp) => { + case op if op != math.systemJ.J2.isOp(onRequest.tpeCase) && op.tags.contains(math.systemJ.J2.IsOp) => import ffiBoolean.booleanCapabilities._ for { booleanFalse <- falseExp } yield Some(booleanFalse) - } case _ => j1Provider.genericLogic(forApproach)(onRequest) } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J3.scala index 4c5ef70a..18cb44af 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J3.scala @@ -1,15 +1,18 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Attribute, Operation, TypeRep} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Strings} +import org.combinators.ep.domain.abstractions.{Attribute, Operation} import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemJ -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object J3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -91,18 +94,19 @@ object J3 { val realResult = onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case systemJ.J3.Divd => { + case systemJ.J3.Divd => for { atts <- attsGen - res <- div(atts: _*) + res <- div(atts*) } yield res - } + case systemJ.J3.Neg => for { atts <- attsGen minusOne <- reify(TypeRep.Double, -1) res <- mult(minusOne, atts.head) } yield res + case _ => ??? } @@ -115,36 +119,37 @@ object J3 { res <- asString(onRequest.attributes(att), ty) } yield res - case math.M0.Add => { + case math.M0.Add => for { atts <- attsGen res <- makeString(atts, "(", "+", ")") } yield res - } - case math.systemJ.J1.Sub => { + + case math.systemJ.J1.Sub => for { atts <- attsGen res <- makeString(atts, "(", "-", ")") } yield res - } - case math.systemJ.J2.Mult => { + + case math.systemJ.J2.Mult => for { atts <- attsGen res <- makeString(atts, "(", "*", ")") } yield res - } - case systemJ.J3.Divd => { + + case systemJ.J3.Divd => for { atts <- attsGen res <- makeString(atts, "(", "/", ")") } yield res - } + case systemJ.J3.Neg => for { atts <- attsGen minus <- reify(TypeRep.String, "-") res <- stringAppend(minus, atts.head) } yield res + case _ => ??? } case _ => ??? diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J4.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J4.scala index 102ad627..6085fa0a 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J4.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J4.scala @@ -1,13 +1,16 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Attribute, Operation, TypeRep} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic +import org.combinators.ep.generator.paradigm.ffi.Trees +import org.combinators.ep.domain.abstractions.{Attribute, Operation} import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Trees} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import org.combinators.ep.domain.abstractions.DomainTpeRep object J4 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -53,7 +56,7 @@ object J4 { case op if op == Operation.asTree => for { children <- forEach(onRequest.attributes.toSeq) { - case (att@Attribute(_, TypeRep.DataType(dt)), attExp) => + case (att@Attribute(_, DomainTpeRep.DataType(dt)), attExp) => forApproach.dispatch( SendRequest( attExp, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J5.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J5.scala index 62db93b7..68c1ea0f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J5.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J5.scala @@ -1,13 +1,12 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Booleans, Equality} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation} import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.domain.math.systemJ -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Booleans, Equality} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J5 { @@ -68,7 +67,7 @@ object J5 { Request(Operation.asTree, Map.empty) ) ) - treeTpe <- toTargetLanguageType(TypeRep.Tree) + treeTpe <- toTargetLanguageType(DomainTpeRep.Tree) eq <- areEqual(treeTpe, selfTree, otherTree) } yield Some(eq) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6.scala index f285e1ac..99de32a6 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{Operation, Parameter} import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemJ -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J6 { @@ -20,7 +21,7 @@ object J6 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { override val model: GenericModel = math.systemJ.J6.getModel diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6funct.scala index 8dab7150..b40ed903 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJ/J6funct.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips.systemJ /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, Parameter, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation, Parameter} import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemJ -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, control} -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J6funct { @@ -117,7 +118,7 @@ object J6funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) expName <- freshName(forApproach.names.mangle("exponentValue")) expType <- toTargetLanguageType(TypeRep.Double) @@ -130,7 +131,7 @@ object J6funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - powByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + powByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) powByRecName <- freshName(forApproach.names.mangle("powByRec")) powByRecArg <- freshName(forApproach.names.mangle("exponentValue")) finalResult <- declareRecursiveVariable(powByRecName, powByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J7.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J7.scala index 41a46ba1..25094661 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J7.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J7.scala @@ -1,20 +1,21 @@ package org.combinators.ep.domain.math.eips.systemJK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} import org.combinators.ep.domain.math.systemK.{K1, K2} import org.combinators.ep.domain.math.{systemJK, systemK} import org.combinators.ep.domain.{GenericModel, abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} -// Code for M8. Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be -// used in an uniform way. +// Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be used in an uniform way. sealed class J7[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = @@ -81,7 +82,7 @@ sealed class J7[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio import syntax._ def evalChildren(tpe: DataTypeCase, atts: Map[abstractions.Attribute, Expression]): Generator[MethodBodyContext, List[Expression]] = - forEach(atts.keys.toSeq) { att: abstractions.Attribute => { + forEach(atts.keys.toSeq) { (att: abstractions.Attribute) => { val expr: Expression = atts(att) forApproach.dispatch( SendRequest( @@ -189,12 +190,6 @@ sealed class J7[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio val pastOps = math.systemJ.J2.isOps(model.flatten.typeCases) if (pastOps.contains(onRequest.request.op)) { genericLogic(forApproach)(onRequest) -// } else if (onRequest.request.op == math.J1.MultBy) { -// /* Handle MultBy with these data types. */ -// onRequest.tpeCase match { -// case math.J4.Power => genericLogic(forApproach)(onRequest) -// case _ => ??? -// } } else { val atts = for { atts <- forEach(onRequest.tpeCase.attributes) { att => @@ -289,7 +284,7 @@ object J7 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (k2j6Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], @@ -309,7 +304,7 @@ object J7 { def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (k2j6Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8.scala index 6260a910..cecbfed5 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8.scala @@ -1,15 +1,16 @@ package org.combinators.ep.domain.math.eips.systemJK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemJK -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J8 { @@ -18,7 +19,7 @@ object J8 { (j7Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiImper: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val j8Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { override val model: GenericModel = math.systemJK.J8.getModel @@ -62,7 +63,7 @@ object J8 { maxName <- freshName(forApproach.names.mangle("max")) maxDecl <- ffiImper.imperativeCapabilities.declareVar(maxName, intType, Some(zero)) - _ <- forEach(onRequest.attributes.toSeq) { case (att, expr) => { + _ <- forEach(onRequest.attributes.toSeq) { case (att, expr) => for { attName <- freshName(forApproach.names.mangle(att.name)) exprVal <- forApproach.dispatch( @@ -85,7 +86,6 @@ object J8 { _ <- addBlockDefinitions(Seq(ifStmt)) } yield () } - } resExpr <- ffiArithmetic.arithmeticCapabilities.add(maxDecl, one) } yield Some(resExpr) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8funct.scala index cba426ec..9318c235 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/J8funct.scala @@ -1,13 +1,15 @@ package org.combinators.ep.domain.math.eips.systemJK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, control} -import org.combinators.ep.generator.paradigm.ffi.Arithmetic +import org.combinators.cogen.paradigm.control import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object J8funct { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/K2J6.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/K2J6.scala index 7c258d21..bc64dee1 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/K2J6.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemJK/K2J6.scala @@ -1,22 +1,23 @@ package org.combinators.ep.domain.math.eips.systemJK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} import org.combinators.ep.domain.math.systemJK import org.combinators.ep.domain.{GenericModel, abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} /** Upon merging M7 and I2 there is a need for MultByx(Divd, Mult, Neg) as well as a need for - * (Collect,Simplify,Id,AsTree,Equals,PowBy)xPower - * - * These all have to be captured here... - */ + * (Collect,Simplify,Id,AsTree,Equals,PowBy)xPower + * + * These all have to be captured here... + */ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P], IfBlockType](val paradigm: P) { type IfThenElseCommand = @@ -28,12 +29,12 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]], k2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], - returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], - ifThenElse: IfThenElseCommand): + (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], + returnInIf: Generator[paradigm.MethodBodyContext, paradigm.syntax.Expression] => Generator[paradigm.MethodBodyContext, IfBlockType], + ifThenElse: IfThenElseCommand): EvolutionImplementationProvider[AIP[paradigm.type]] = { val k2j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { @@ -50,16 +51,16 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } yield () } - // k1 <- k2 - // K1(Seq(Power), J2.isOps(Seq(Power)))), K2("k2", Seq.empty, Seq(Simplify, Collect))) + // k1 <- k2 + // K1(Seq(Power), J2.isOps(Seq(Power)))), K2("k2", Seq.empty, Seq(Simplify, Collect))) - // j1 <- j2 <- j3 <- j4 <- j5 <- j6 - // J1 Seq(Sub), Seq(MultBy)) - // J2 Seq(Mult), Seq(Eql) ++ isOps(allTypes)) - // J3 Seq(Neg, Divd), Seq(PrettyP) ++ J2.isOps(Seq(Neg,Divd))) - // J4 ("j4", Seq.empty, Seq(Operation.asTree, Identifier)) - // J5 Seq.empty, Seq(Equals)) - // J6 Seq.empty, Seq(PowBy)) + // j1 <- j2 <- j3 <- j4 <- j5 <- j6 + // J1 Seq(Sub), Seq(MultBy)) + // J2 Seq(Mult), Seq(Eql) ++ isOps(allTypes)) + // J3 Seq(Neg, Divd), Seq(PrettyP) ++ J2.isOps(Seq(Neg,Divd))) + // J4 ("j4", Seq.empty, Seq(Operation.asTree, Identifier)) + // J5 Seq.empty, Seq(Equals)) + // J6 Seq.empty, Seq(PowBy)) override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { val cases = systemJK.K2J6.getModel.flatten.typeCases (potentialRequest.op, potentialRequest.tpeCase) match { @@ -93,7 +94,7 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat // Simplify of Power -- if exponent is 1, then ignore! If exponent is 0, turn to 1; if exponent is -1, turn to DivD private def simplifyLogic(forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[forApproach.paradigm.MethodBodyContext, Option[forApproach.paradigm.syntax.Expression]] = { import AnyParadigm.syntax._ import ffiEquality.equalityCapabilities._ @@ -102,7 +103,7 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat import syntax._ def evalChildren(tpe:DataTypeCase, atts: Map[abstractions.Attribute,Expression]): Generator[MethodBodyContext, List[Expression]] = - forEach (atts.keys.toSeq) { att:abstractions.Attribute => { + forEach (atts.keys.toSeq) { (att:abstractions.Attribute) => { val expr:Expression = atts(att) forApproach.dispatch( SendRequest( @@ -124,15 +125,15 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } def simplifyOp( - atts:Seq[abstractions.Attribute], - attExprs: Seq[Expression], - vals: Generator[MethodBodyContext, List[Expression]], - doubleTy: Type, - zero: Expression, - one: Expression, - zeroLit: Generator[MethodBodyContext, Expression], - oneLit: Generator[MethodBodyContext, Expression] - ): Generator[MethodBodyContext, Option[Expression]] = { + atts:Seq[abstractions.Attribute], + attExprs: Seq[Expression], + vals: Generator[MethodBodyContext, List[Expression]], + doubleTy: Type, + zero: Expression, + one: Expression, + zeroLit: Generator[MethodBodyContext, Expression], + oneLit: Generator[MethodBodyContext, Expression] + ): Generator[MethodBodyContext, Option[Expression]] = { import ffiArithmetic.arithmeticCapabilities._ import ffiBoolean.booleanCapabilities._ onRequest.tpeCase match { @@ -233,9 +234,9 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat } // should be no need to define genericLogic since (by default) it will go through the chain of past providers... - override def genericLogic + override def genericLogic (forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[forApproach.paradigm.MethodBodyContext, Option[forApproach.paradigm.syntax.Expression]] = { try { j6Provider.genericLogic(forApproach)(onRequest) @@ -246,7 +247,7 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat def logic (forApproach: AIP[paradigm.type]) - (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): + (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) @@ -277,15 +278,15 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat onRequest.tpeCase match { case math.systemK.K1.Power => for { - atts <- forEach(onRequest.tpeCase.attributes) { att => - forApproach.dispatch(SendRequest( - onRequest.attributes(att), - math.systemJ.J3.getModel.baseDataType, - onRequest.request - )) - } - res <- makeString(atts, "(", "^", ")") - } yield Some(res) + atts <- forEach(onRequest.tpeCase.attributes) { att => + forApproach.dispatch(SendRequest( + onRequest.attributes(att), + math.systemJ.J3.getModel.baseDataType, + onRequest.request + )) + } + res <- makeString(atts, "(", "^", ")") + } yield Some(res) case _ => ??? } case math.systemK.K2.Simplify => simplifyLogic(forApproach)(onRequest) @@ -295,7 +296,7 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat case math.systemK.K2.Collect => k2Provider.genericLogic(forApproach)(onRequest) case p@math.systemJ.J6.PowBy => // on Power - // must handle Power dataType. HERE WE CAN OPTIMIZED. + // must handle Power dataType. HERE WE CAN OPTIMIZED. for { res <- forApproach.instantiate(math.M0.getModel.baseDataType, math.systemK.K1.Power, onRequest.selfReference, onRequest.request.arguments.head._2) } yield Some(res) @@ -312,14 +313,14 @@ sealed class K2J6[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementat object K2J6 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] - (paradigm: P) - (j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]], - k2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): + (paradigm: P) + (j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]], + k2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import paradigm.syntax._ val mkImpl = new K2J6[paradigm.type, AIP, Expression](paradigm) @@ -333,14 +334,14 @@ object K2J6 { } def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] - (paradigm: P) - (j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]], - k2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): + (paradigm: P) + (j6Provider: EvolutionImplementationProvider[AIP[paradigm.type]], + k2Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], + ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], + ffiEquality: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { import imperativeControl.imperativeCapabilities._ import paradigm.methodBodyCapabilities._ diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K1.scala index fe272e42..fdf2e057 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K1.scala @@ -1,14 +1,13 @@ package org.combinators.ep.domain.math.eips.systemK /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, RealArithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.domain.math.{systemJ, systemK} -import org.combinators.ep.generator.Command.Generator +import org.combinators.ep.domain.math.systemK +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object K1 { @@ -81,17 +80,11 @@ object K1 { val pastOps = math.systemJ.J2.isOps(model.flatten.typeCases) if (pastOps.contains(onRequest.request.op)) { genericLogic(forApproach)(onRequest) - // } else if (onRequest.request.op == math.J1.MultBy) { - // /* Handle MultBy with these data types. */ - // onRequest.tpeCase match { - // case math.K1.Power => genericLogic(forApproach)(onRequest) - // case _ => ??? - // } } else if (onRequest.request.op == math.systemJ.J2.Eql) { genericLogic(forApproach)(onRequest) } else { val result = onRequest.tpeCase match { - case power@systemK.K1.Power => { + case power@systemK.K1.Power => onRequest.request.op match { case eval@math.M0.Eval => for { @@ -133,7 +126,7 @@ object K1 { ^^^^ is expExpr ^^^ addend ^^^ numExpr **/ - //eulerNumFixMe <- forApproach.reify(InstanceRep(TypeRep.Double)(2.7182818284590452354)) + //eulerNumFixMe <- forApproach.reify(DataTypeInstanceRep(TypeRep.Double)(2.7182818284590452354)) numExpr <- log(baseEval, other) // denomExpr <- log(eulerNumFixMe, baseEval) // fraction <- div(numExpr, denomExpr) @@ -149,7 +142,6 @@ object K1 { case _ => ??? } - } case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K2.scala index fccdb06e..c0d5c1f9 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemK/K2.scala @@ -1,16 +1,16 @@ package org.combinators.ep.domain.math.eips.systemK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.{Command, InstanceRep, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, Equality, Lists, Strings} +import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation} import org.combinators.ep.domain.math.systemK import org.combinators.ep.domain.{GenericModel, abstractions, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.{Functional, Imperative} -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, Equality, Lists, Strings} -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} // Takes adapters for return in if-then-else, s.t. functional- and imperative-style if-then-else can be // used in an uniform way. @@ -121,7 +121,7 @@ sealed class K2[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementatio import syntax._ def evalChildren(tpe:DataTypeCase, atts: Map[abstractions.Attribute,Expression]): Generator[MethodBodyContext, List[Expression]] = - forEach (atts.keys.toSeq) { att:abstractions.Attribute => { + forEach (atts.keys.toSeq) { (att:abstractions.Attribute) => { val expr:Expression = atts(att) forApproach.dispatch( SendRequest( @@ -286,7 +286,7 @@ object K2 { def functional[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (k1Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (functionalControl: Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], + (functionalControl: control.Functional.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], @@ -307,7 +307,7 @@ object K2 { def imperative[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (k1Provider : EvolutionImplementationProvider[AIP[paradigm.type]]) - (imperativeControl: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], + (imperativeControl: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiBoolean: Booleans.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1.scala index 7c912da5..4fa61569 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1.scala @@ -1,12 +1,12 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object O1 { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1OA.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1OA.scala index 8cd5030a..4de0bbb5 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1OA.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O1OA.scala @@ -1,13 +1,12 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object O1OA { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -27,15 +26,6 @@ object O1OA { } override def dependencies(potentialRequest: PotentialRequest): Option[Set[Operation]] = { -// // if not careful, the overridden Eval for oa is ignored because o1 has an Eval for Lit. Have to call this out -// // ditto for prettyp -// if ((potentialRequest.op == math.M0.Eval) && Set(math.M0.Lit).contains(potentialRequest.tpeCase)) { -// Some(Set.empty) -// } else if ((potentialRequest.op == math.M2.PrettyP) && Set(math.M0.Lit).contains(potentialRequest.tpeCase)) { -// Some(Set.empty) -// } else { -// None -// } None } @@ -43,23 +33,9 @@ object O1OA { (forApproach: AIP[paradigm.type]) (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): Generator[paradigm.MethodBodyContext, Option[paradigm.syntax.Expression]] = { - import paradigm._ ??? -// // WON'T BE CALLED BUT NEED SOMETHING -// val result = onRequest.tpeCase match { -// /** Get and return first (and only) attribute. */ -// case litC@math.M0.Lit => -// if (onRequest.request.op == math.M2.PrettyP) { -// o1Provider.logic(forApproach)(onRequest) -// } else if (onRequest.request.op == math.M0.Eval) { -// oaProvider.logic(forApproach)(onRequest) -// } else { -// ??? -// } -// } -// result } } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O2.scala index c3d68af5..d5565a3f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/O2.scala @@ -1,12 +1,12 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation -import org.combinators.ep.domain.math -import org.combinators.ep.generator.Command.Generator +import org.combinators.ep.domain.{GenericModel, math} +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object O2 { @@ -17,7 +17,7 @@ object O2 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val o2Provider:EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemO.O2.getModel + override val model: GenericModel = math.systemO.O2.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OA.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OA.scala index 69cb63aa..e9a76d0d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OA.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OA.scala @@ -1,14 +1,14 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.{Command, InstanceRep, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.Arithmetic +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance -import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object OA { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] @@ -36,12 +36,6 @@ object OA { } } -// /** Do not call 'assert' since might not be applicable. */ -// override def genericLogic(forApproach: AIP[paradigm.type]) -// (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): -// Generator[forApproach.paradigm.MethodBodyContext, Option[forApproach.paradigm.syntax.Expression]] = -// m2Provider.genericLogic(forApproach)(onRequest) - def logic (forApproach: AIP[paradigm.type]) (onRequest: ReceivedRequest[forApproach.paradigm.syntax.Expression]): @@ -51,10 +45,6 @@ object OA { assert(dependencies(PotentialRequest(onRequest.onType, onRequest.tpeCase, onRequest.request.op)).nonEmpty) val result = onRequest.tpeCase match { - /** Get and return first (and only) attribute. */ -// case litC@math.M0.Lit => { -// Command.lift[MethodBodyContext, paradigm.syntax.Expression](onRequest.attributes(litC.attributes.head)) -// } /** Wherever a literal value was used, replace with "litv + 0" */ case litC@math.M0.Lit => diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD1.scala index 60dbea03..d2607abb 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD1.scala @@ -1,14 +1,16 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object OD1 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -57,7 +59,7 @@ object OD1 { onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case math.systemO.OD1.Mult => mult(atts: _*) + case math.systemO.OD1.Mult => mult(atts*) case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD2.scala index 1254331c..971c10ed 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD2.scala @@ -1,16 +1,16 @@ -package org.combinators.ep.domain.math.eips.systemO - -/*DD:LI:AI*/ +package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object OD2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -59,7 +59,7 @@ object OD2 { onRequest.request.op match { case math.M0.Eval => onRequest.tpeCase match { - case math.systemO.OD2.Divd => div(atts: _*) + case math.systemO.OD2.Divd => div(atts*) case _ => ??? } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD3.scala index b2420705..7ffa5f1a 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OD3.scala @@ -1,12 +1,13 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ +import org.combinators.cogen.Command +import org.combinators.cogen.paradigm.AnyParadigm import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object OD3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO1.scala index 05d84bdd..f4fd298c 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO1.scala @@ -1,13 +1,13 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} object OO1 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO2.scala index af02518e..d50829b7 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO2.scala @@ -1,13 +1,13 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, RealArithmetic, Strings} object OO2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO3.scala index e6e08e01..97e87a42 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemO/OO3.scala @@ -1,12 +1,13 @@ package org.combinators.ep.domain.math.eips.systemO /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.{ApproachImplementationProvider, Command, EvolutionImplementationProvider} +import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import org.combinators.cogen.Command object OO3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1.scala index cd63bf67..cde088eb 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1.scala @@ -1,17 +1,20 @@ package org.combinators.ep.domain.math.eips.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemX -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object X1 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -20,7 +23,7 @@ object X1 { ffiRealArithmetic: RealArithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], ffiEquals: Equality.WithBase[paradigm.MethodBodyContext, paradigm.type], ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type], - ffiImper: Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): + ffiImper: control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val x1Provider: EvolutionImplementationProvider[AIP[paradigm.type]] = new EvolutionImplementationProvider[AIP[paradigm.type]] { @@ -63,7 +66,7 @@ object X1 { case systemX.X1.Sub => for { atts <- forEach(attGenerators)(g => g) - result <- sub(atts: _*) + result <- sub(atts*) } yield result case _ => ??? diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1funct.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1funct.scala index 7faf922c..5fe71ed1 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1funct.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X1funct.scala @@ -1,17 +1,20 @@ package org.combinators.ep.domain.math.eips.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.{DomainTpeRep, Operation} import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemX -import org.combinators.ep.generator.Command.{Generator, lift} +import org.combinators.cogen.Command.{Generator, lift} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Equality, RealArithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object X1funct { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -66,7 +69,7 @@ object X1funct { case systemX.X1.Sub => for { atts <- forEach(attGenerators)(g => g) - result <- sub(atts: _*) + result <- sub(atts*) } yield result case _ => ??? @@ -128,7 +131,7 @@ object X1funct { case litC@math.M0.Lit => for { - resultTpe <- toTargetLanguageType(TypeRep.DataType(math.M2.getModel.baseDataType)) + resultTpe <- toTargetLanguageType(DomainTpeRep.DataType(math.M2.getModel.baseDataType)) multName <- freshName(forApproach.names.mangle("multiplier")) multType <- toTargetLanguageType(TypeRep.Double) @@ -141,7 +144,7 @@ object X1funct { zero <- forApproach.reify(InstanceRep(TypeRep.Double)(0.0)) one <- forApproach.reify(InstanceRep(TypeRep.Double)(1.0)) - multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, TypeRep.DataType(math.M2.getModel.baseDataType))) + multByRecTpe <- toTargetLanguageType(TypeRep.Arrow(TypeRep.Double, DomainTpeRep.DataType(math.M2.getModel.baseDataType))) multByRecName <- freshName(forApproach.names.mangle("multByRec")) multByRecArg <- freshName(forApproach.names.mangle("multiplier")) finalResult <- declareRecursiveVariable(multByRecName, multByRecTpe, diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2.scala index 271e6191..530fccd6 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2.scala @@ -1,15 +1,17 @@ package org.combinators.ep.domain.math.eips.systemX /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemX -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object X2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -55,7 +57,7 @@ object X2 { case systemX.X2.Times => for { atts <- forEach(attGenerators)(g => g) - result <- mult(atts: _*) + result <- mult(atts*) } yield result case _ => ??? diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2X3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2X3.scala index be6b3f73..9eaeed26 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2X3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X2X3.scala @@ -1,11 +1,11 @@ package org.combinators.ep.domain.math.eips.systemX /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object X2X3 { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X3.scala index 636422fb..6682ba76 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X3.scala @@ -1,15 +1,17 @@ package org.combinators.ep.domain.math.eips.systemX /*DD:LI:AI*/ +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.domain.abstractions.Operation -import org.combinators.ep.domain.math +import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemX -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} +import scala.language.postfixOps + object X3 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) @@ -18,7 +20,7 @@ object X3 { ffiStrings: Strings.WithBase[paradigm.MethodBodyContext, paradigm.type]): EvolutionImplementationProvider[AIP[paradigm.type]] = { val x3Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { - override val model = math.systemX.X3.getModel + override val model: GenericModel = math.systemX.X3.getModel def initialize(forApproach: AIP[paradigm.type]): Generator[forApproach.paradigm.ProjectContext, Unit] = { for { @@ -55,7 +57,7 @@ object X3 { case systemX.X3.Divd => for { atts <- forEach(attGenerators)(g => g) - result <- div(atts: _*) + result <- div(atts*) } yield result case _ => ??? diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X4.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X4.scala index a3da2053..1d39db4e 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X4.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/eips/systemX/X4.scala @@ -1,13 +1,14 @@ package org.combinators.ep.domain.math.eips.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, math} import org.combinators.ep.domain.math.systemX -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Strings} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} object X4 { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1.scala index c08ba952..4763b301 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemD /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.{M1, M2} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -9,8 +12,8 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object D1 extends Evolution { override implicit def getModel: GenericModel = M1.getModel.evolve("d1", Seq.empty, Seq(MultBy)) - lazy val base = TypeRep.DataType(M2.getModel.baseDataType) - lazy val MultBy = Operation("multBy", base, Seq(Parameter("other", base))) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(M2.getModel.baseDataType) + lazy val MultBy: Operation = Operation("multBy", base, Seq(Parameter("other", base))) object MultByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected: InstanceRep): TestCase = { @@ -23,13 +26,13 @@ object D1 extends Evolution { def tests: Seq[TestCase] = Seq( MultByTestCase(AddInst(LitInst(1.0), LitInst(2.0)), - InstanceRep(LitInst(3.0)), DoubleInst(9.0)), + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(9.0)), MultByTestCase(AddInst(LitInst(1.0), LitInst(2.0)), - InstanceRep(LitInst(3.0)), DoubleInst(9.0)), + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(9.0)), MultByTestCase(LitInst(2.0), - InstanceRep(LitInst(0.0)), DoubleInst(0.0)), + DataTypeInstanceRep(LitInst(0.0)), DoubleInst(0.0)), MultByTestCase(LitInst(0.0), - InstanceRep(LitInst(3.0)), DoubleInst(0.0)) + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(0.0)) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1D2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1D2.scala index 9d67c73e..90cc0b3c 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1D2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D1D2.scala @@ -1,6 +1,6 @@ package org.combinators.ep.domain.math.systemD /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.TestCase +import org.combinators.cogen.TestCase import org.combinators.ep.domain.{Evolution, GenericModel} object D1D2 extends Evolution { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D2.scala index 6f034803..fe46192d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D2.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemD /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.{M0, M1, MathDomain} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -9,19 +11,17 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object D2 extends Evolution { override implicit def getModel: GenericModel = M1.getModel.evolve("d2", Seq(Mult), Seq.empty) - // m3:model evolution. - // ------------------- - lazy val Mult = DataTypeCase.binary("Mult")(MathDomain.getModel) + lazy val Mult: DataTypeCase = DataTypeCase.binary("Mult")(MathDomain.getModel) def MultInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Mult, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Mult, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val m3_s1 = MultInst(LitInst(2.0), LitInst(3.0)) + val d2_m1: DataTypeInstance = MultInst(LitInst(2.0), LitInst(3.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M1) def tests: Seq[TestCase] = Seq( - EqualsTestCase(getModel.baseDataType, m3_s1, Eval, M0.DoubleInst(6.0)), + EqualsTestCase(getModel.baseDataType, d2_m1, Eval, M0.DoubleInst(6.0)), ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D3.scala index 88045dfa..bafa292f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemD/D3.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemD /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.{TestCase, TypeRep} +import org.combinators.ep.domain.abstractions.{EqualsTestCase, Operation} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, LitInst} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.{Evolution, GenericModel} @@ -11,18 +13,18 @@ object D3 extends Evolution { def StringInst(s: String): InstanceRep = InstanceRep(TypeRep.String)(s) - lazy val PrettyP = Operation("prettyp", TypeRep.String) + lazy val PrettyP: Operation = Operation("prettyp", TypeRep.String) // Tests - val m2_s1 = SubInst(LitInst(1.0), LitInst(2.0)) + val d3_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(2.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(D1D2) def tests: Seq[TestCase] = Seq( //EqualsTestCase(m2_s1, PrettyP, ExistsInstance(String)("(1.0-2.0)")), - EqualsTestCase(getModel.baseDataType, m2_s1, PrettyP, StringInst("(1.0-2.0)")), + EqualsTestCase(getModel.baseDataType, d3_s1, PrettyP, StringInst("(1.0-2.0)")), - EqualsTestCase(getModel.baseDataType, AddInst(m2_s1, AddInst(LitInst(5.0), LitInst(6.0))), + EqualsTestCase(getModel.baseDataType, AddInst(d3_s1, AddInst(LitInst(5.0), LitInst(6.0))), PrettyP, StringInst("((1.0-2.0)+(5.0+6.0))")) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I1.scala index 87557e57..c9aee41b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I1.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemI /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.M2 import org.combinators.ep.domain.{Evolution, GenericModel} @@ -9,8 +12,8 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object I1 extends Evolution { override implicit def getModel: GenericModel = M2.getModel.evolve("i1", Seq.empty, Seq(MultBy)) - lazy val base = TypeRep.DataType(M2.getModel.baseDataType) - lazy val MultBy = Operation("multBy", base, Seq(Parameter("other", base))) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(M2.getModel.baseDataType) + lazy val MultBy: Operation = Operation("multBy", base, Seq(Parameter("other", base))) object MultByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected: InstanceRep): TestCase = { @@ -23,10 +26,10 @@ object I1 extends Evolution { def tests: Seq[TestCase] = Seq( MultByTestCase(AddInst(LitInst(1.0), LitInst(2.0)), - InstanceRep(LitInst(3.0)), DoubleInst(9.0)), + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(9.0)), MultByTestCase(AddInst(LitInst(1.0), LitInst(2.0)), - InstanceRep(LitInst(0.0)), DoubleInst(0.0)), + DataTypeInstanceRep(LitInst(0.0)), DoubleInst(0.0)), MultByTestCase(LitInst(0.0), - InstanceRep(LitInst(3.0)), DoubleInst(0.0)) + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(0.0)) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I2.scala index 38dfe943..ee93aa26 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemI/I2.scala @@ -1,21 +1,20 @@ package org.combinators.ep.domain.math.systemI /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.MathDomain import org.combinators.ep.domain.{Evolution, GenericModel} -// TODO: I2 still generates multBy twice in Power. object I2 extends Evolution { override implicit def getModel: GenericModel = I1.getModel.evolve("i2", Seq(Power), Seq.empty) - // i2:model evolution. - // ------------------- lazy val Power: DataTypeCase = DataTypeCase.binary("Power")(MathDomain.getModel) def PowerInst(base: DataTypeInstance, exponent: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Power, Seq(InstanceRep(base), InstanceRep(exponent))) + DataTypeInstance(Power, Seq(DataTypeInstanceRep(base), DataTypeInstanceRep(exponent))) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(I1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J1.scala index 9b30fc45..2921a6ba 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J1.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{DoubleInst, LitInst, addi, liti} import org.combinators.ep.domain.math.{M0, MathDomain} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -9,15 +12,15 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J1 extends Evolution { override implicit def getModel: GenericModel = M0.getModel.evolve("j1", Seq(Sub), Seq(MultBy)) - lazy val base = TypeRep.DataType(M0.getModel.baseDataType) // go to previous one, o/w recursion hits - lazy val MultBy = Operation("multBy", base, Seq(Parameter("other", base))) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(M0.getModel.baseDataType) // go to previous one, o/w recursion hits + lazy val MultBy: Operation = Operation("multBy", base, Seq(Parameter("other", base))) // m1:model evolution. // ------------------- lazy val Sub: DataTypeCase = DataTypeCase.binary("Sub")(MathDomain.getModel) def SubInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Sub, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Sub, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) object MultByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected: InstanceRep): TestCase = { @@ -33,10 +36,10 @@ object J1 extends Evolution { def tests: Seq[TestCase] = Seq( EqualsTestCase(getModel.baseDataType, subi, M0.Eval, M0.DoubleInst(-1.0)), - MultByTestCase(liti, InstanceRep(LitInst(3.0)), DoubleInst(15.0)), - MultByTestCase(liti, InstanceRep(subi), DoubleInst(-5.0)), - MultByTestCase(addi, InstanceRep(LitInst(3.0)), DoubleInst(9.0)), - MultByTestCase(subi, InstanceRep(LitInst(3.0)), DoubleInst(-3.0)), - MultByTestCase(LitInst(-2.0), InstanceRep(LitInst(3.0)), DoubleInst(-6.0)) + MultByTestCase(liti, DataTypeInstanceRep(LitInst(3.0)), DoubleInst(15.0)), + MultByTestCase(liti, DataTypeInstanceRep(subi), DoubleInst(-5.0)), + MultByTestCase(addi, DataTypeInstanceRep(LitInst(3.0)), DoubleInst(9.0)), + MultByTestCase(subi, DataTypeInstanceRep(LitInst(3.0)), DoubleInst(-3.0)), + MultByTestCase(LitInst(-2.0), DataTypeInstanceRep(LitInst(3.0)), DoubleInst(-6.0)) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J2.scala index 6edf32dd..9ebf0c03 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J2.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.{InstanceRep, TypeRep} +import org.combinators.cogen.{Tag, TestCase} import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.{DataTypeInstance, DataTypeInstanceRep} import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst, addi, liti} import org.combinators.ep.domain.math.systemJ.J1.{MultByTestCase, SubInst, subi} import org.combinators.ep.domain.math.{M0, MathDomain} @@ -10,7 +12,7 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J2 extends Evolution { override implicit def getModel: GenericModel = J1.getModel.evolve("j2", Seq(Mult), Seq(Eql) ++ isOps(allTypes)) - lazy val allTypes = J1.getModel.flatten.typeCases :+ Mult + lazy val allTypes: Seq[DataTypeCase] = J1.getModel.flatten.typeCases :+ Mult def isOps(tpeCases: Seq[DataTypeCase]): Seq[Operation] = { tpeCases.map(tpe => isOp(tpe)) @@ -32,16 +34,15 @@ object J2 extends Evolution { // and then use those structure(s) to determine equality. // EQL depends on past IsXXX which you know from ALL PAST evolutions - lazy val Eql = Operation("eql", TypeRep.Boolean, Seq(Parameter("other", TypeRep.DataType(J1.getModel.baseDataType)))) // base case from prior evolution + lazy val Eql: Operation = Operation("eql", TypeRep.Boolean, Seq(Parameter("other", DomainTpeRep.DataType(J1.getModel.baseDataType)))) // base case from prior evolution - lazy val Mult = DataTypeCase.binary("Mult")(MathDomain.getModel) + lazy val Mult: DataTypeCase = DataTypeCase.binary("Mult")(MathDomain.getModel) def MultInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Mult, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Mult, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - // (5/7) / (7-(2*3) --> just (5/7) - val multi = MultInst(LitInst(2.0), LitInst(3.0)) + val multi: DataTypeInstance = MultInst(LitInst(2.0), LitInst(3.0)) object EqualsBinaryMethodTestCase { def apply(op: Operation, instance: DataTypeInstance, instance1: DataTypeInstance, result: Boolean): TestCase = { @@ -50,23 +51,23 @@ object J2 extends Evolution { instance, op, InstanceRep(TypeRep.Boolean)(result), - InstanceRep.apply(instance1)(getModel) + DataTypeInstanceRep.apply(instance1)(getModel) ) } } - val addi_same_lhs = AddInst(LitInst(1.0), LitInst(3.0)) - val addi_same_rhs = AddInst(LitInst(3.0), LitInst(2.0)) - val subi_same_lhs = SubInst(LitInst(1.0), LitInst(3.0)) - val subi_same_rhs = SubInst(LitInst(3.0), LitInst(2.0)) - val multi_same_lhs = MultInst(LitInst(1.0), LitInst(3.0)) - val multi_same_rhs = MultInst(LitInst(3.0), LitInst(2.0)) + val addi_same_lhs: DataTypeInstance = AddInst(LitInst(1.0), LitInst(3.0)) + val addi_same_rhs: DataTypeInstance = AddInst(LitInst(3.0), LitInst(2.0)) + val subi_same_lhs: DataTypeInstance = SubInst(LitInst(1.0), LitInst(3.0)) + val subi_same_rhs: DataTypeInstance = SubInst(LitInst(3.0), LitInst(2.0)) + val multi_same_lhs: DataTypeInstance = MultInst(LitInst(1.0), LitInst(3.0)) + val multi_same_rhs: DataTypeInstance = MultInst(LitInst(3.0), LitInst(2.0)) // generate all mismatched Eqls from this // also cover all cases by creating pairs of Op(val1,val2) to be compared against Op(val1,val3) and Op(val3,val2) - val all_instances = Seq(liti, addi, subi, multi) - val lhs = Seq(LitInst(-99), addi_same_lhs, subi_same_lhs, multi_same_lhs) // changes on left hand side - val rhs = Seq(LitInst(99), addi_same_rhs, subi_same_rhs, multi_same_rhs) // changes on right hand side + val all_instances: Seq[DataTypeInstance] = Seq(liti, addi, subi, multi) + val lhs: Seq[DataTypeInstance] = Seq(LitInst(-99), addi_same_lhs, subi_same_lhs, multi_same_lhs) // changes on left hand side + val rhs: Seq[DataTypeInstance] = Seq(LitInst(99), addi_same_rhs, subi_same_rhs, multi_same_rhs) // changes on right hand side /** Useful helper function to define essential eql=true test cases for instances */ def eqls(instances: Seq[DataTypeInstance]): Seq[TestCase] = { @@ -110,7 +111,7 @@ object J2 extends Evolution { def tests: Seq[TestCase] = Seq( EqualsTestCase(getModel.baseDataType, multi, Eval, M0.DoubleInst(6.0)), - MultByTestCase(MultInst(LitInst(3.0), LitInst(2.0)), InstanceRep(LitInst(5.0)), DoubleInst(30.0)), - MultByTestCase(MultInst(LitInst(-3.0), LitInst(2.0)), InstanceRep(LitInst(-5.0)), DoubleInst(30.0)), + MultByTestCase(MultInst(LitInst(3.0), LitInst(2.0)), DataTypeInstanceRep(LitInst(5.0)), DoubleInst(30.0)), + MultByTestCase(MultInst(LitInst(-3.0), LitInst(2.0)), DataTypeInstanceRep(LitInst(-5.0)), DoubleInst(30.0)), ) ++ eqls(all_instances) ++ not_eqls(all_instances) ++ struct_not_eqls(all_instances, lhs, rhs) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J3.scala index 487c807a..48c8d37b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J3.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.{InstanceRep, TypeRep} +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.{DataTypeInstance, DataTypeInstanceRep} import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst, addi} import org.combinators.ep.domain.math.systemJ.J1.{MultByTestCase, subi} import org.combinators.ep.domain.math.systemJ.J2.{eqls, multi, not_eqls, struct_not_eqls} @@ -11,34 +13,32 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J3 extends Evolution { override implicit def getModel: GenericModel = J2.getModel.evolve("j3", Seq(Neg, Divd), Seq(PrettyP) ++ J2.isOps(Seq(Neg, Divd))) - // m3:model evolution. - // ------------------- - lazy val Neg = DataTypeCase.unary("Neg")(MathDomain.getModel) - lazy val Divd = DataTypeCase.binary("Divd")(MathDomain.getModel) + lazy val Neg: DataTypeCase = DataTypeCase.unary("Neg")(MathDomain.getModel) + lazy val Divd: DataTypeCase = DataTypeCase.binary("Divd")(MathDomain.getModel) def StringInst(s: String): InstanceRep = InstanceRep(TypeRep.String)(s) - lazy val PrettyP = Operation("prettyp", TypeRep.String) + lazy val PrettyP: Operation = Operation("prettyp", TypeRep.String) // Tests def NegInst(inner: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Neg, Seq(InstanceRep(inner))) + DataTypeInstance(Neg, Seq(DataTypeInstanceRep(inner))) def DivdInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Divd, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Divd, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests val negi: DataTypeInstance = NegInst(LitInst(3.0)) val divdi: DataTypeInstance = DivdInst(LitInst(10.0), LitInst(5.0)) - val negi_same_lhs = NegInst(LitInst(1.0)) - val negi_same_rhs = NegInst(LitInst(-1.0)) - val divdi_same_lhs = DivdInst(LitInst(7.0), LitInst(3.0)) - val divdi_same_rhs = DivdInst(LitInst(3.0), LitInst(5.0)) + val negi_same_lhs: DataTypeInstance = NegInst(LitInst(1.0)) + val negi_same_rhs: DataTypeInstance = NegInst(LitInst(-1.0)) + val divdi_same_lhs: DataTypeInstance = DivdInst(LitInst(7.0), LitInst(3.0)) + val divdi_same_rhs: DataTypeInstance = DivdInst(LitInst(3.0), LitInst(5.0)) - val all_instances = J2.all_instances ++ Seq(negi, divdi) - val lhs = J2.lhs ++ Seq(negi_same_lhs, divdi_same_lhs) // changes on left hand side - val rhs = J2.rhs ++ Seq(negi_same_rhs, divdi_same_rhs) // changes on right hand side + val all_instances: Seq[DataTypeInstance] = J2.all_instances ++ Seq(negi, divdi) + val lhs: Seq[DataTypeInstance] = J2.lhs ++ Seq(negi_same_lhs, divdi_same_lhs) // changes on left hand side + val rhs: Seq[DataTypeInstance] = J2.rhs ++ Seq(negi_same_rhs, divdi_same_rhs) // changes on right hand side override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(J2) @@ -53,8 +53,8 @@ object J3 extends Evolution { EqualsTestCase(getModel.baseDataType, subi, PrettyP, StringInst("(1.0-2.0)")), EqualsTestCase(getModel.baseDataType, AddInst(subi, addi), PrettyP, StringInst("((1.0-2.0)+(1.0+2.0))")), - MultByTestCase(divdi, InstanceRep(LitInst(3.0)), DoubleInst(6.0)), - MultByTestCase(negi, InstanceRep(LitInst(3.0)), DoubleInst(-9.0)), + MultByTestCase(divdi, DataTypeInstanceRep(LitInst(3.0)), DoubleInst(6.0)), + MultByTestCase(negi, DataTypeInstanceRep(LitInst(3.0)), DoubleInst(-9.0)), ) ++ eqls(all_instances) ++ not_eqls(all_instances) ++ struct_not_eqls(all_instances, lhs, rhs) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J4.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J4.scala index b30acdfb..6f585073 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J4.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J4.scala @@ -1,7 +1,8 @@ package org.combinators.ep.domain.math.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.{InstanceRep, TestCase, TypeRep} import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Add, AddInst, DoubleInst, Lit, LitInst} import org.combinators.ep.domain.math.systemJ.J1.{Sub, SubInst} import org.combinators.ep.domain.math.systemJ.J2.{Mult, MultInst} @@ -12,21 +13,21 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J4 extends Evolution { override implicit def getModel: GenericModel = J3.getModel.evolve("j4", Seq.empty, Seq(Operation.asTree, Identifier)) - lazy val Identifier = Operation("id", TypeRep.Int) + lazy val Identifier: Operation = Operation("id", TypeRep.Int) - val m5_s1 = AddInst(LitInst(1.0), LitInst(376.0)) - val m5_s2 = AddInst(LitInst(1.0), LitInst(976.0)) - val m5_s3 = SubInst(LitInst(1.0), LitInst(976.0)) + val m5_s1: DataTypeInstance = AddInst(LitInst(1.0), LitInst(376.0)) + val m5_s2: DataTypeInstance = AddInst(LitInst(1.0), LitInst(976.0)) + val m5_s3: DataTypeInstance = SubInst(LitInst(1.0), LitInst(976.0)) - val m5_all = SubInst( - NegInst(LitInst(2.0)), // Sub-Left + val m5_all: DataTypeInstance = SubInst( + NegInst(LitInst(2.0)), // Sub-Left MultInst( // Sub-Right SubInst(LitInst(1.0), LitInst(976.0)), // Mult-Left AddInst( // Mult-Right MultInst(LitInst(1.0), LitInst(976.0)), DivdInst(LitInst(1.0), LitInst(3.0))))) - val tree_m5_all = + val tree_m5_all:Node = Node(Sub.name.hashCode, Seq( Node(Neg.name.hashCode, Seq(Node(Lit.name.hashCode, Seq(Leaf(DoubleInst(2.0)))))), // Sub-Left @@ -53,10 +54,10 @@ object J4 extends Evolution { )) // Mult-Right )) - val m5_s4 = MultInst(MultInst(LitInst(2.0), LitInst(1.0)), + val m5_s4: DataTypeInstance = MultInst(MultInst(LitInst(2.0), LitInst(1.0)), AddInst(LitInst(0.0), LitInst(7.0))) - val treeSimplified = + val treeSimplified:Node = Node(Mult.name.hashCode, Seq( Node(Lit.name.hashCode, Seq(Leaf(DoubleInst(2.0)))), @@ -85,7 +86,7 @@ object J4 extends Evolution { SameTestCase(m5_s1, m5_s3, expected = true), SameTestCase(m5_all, m5_all, expected = true), - EqualsTestCase(getModel.baseDataType, m5_all, Operation.asTree, InstanceRep(TypeRep.Tree)(tree_m5_all)), + EqualsTestCase(getModel.baseDataType, m5_all, Operation.asTree, InstanceRep(DomainTpeRep.Tree)(tree_m5_all)), EqualsCompositeTestCase(getModel.baseDataType, m5_all, StringInst("(-2.0-((1.0-976.0)*((1.0*976.0)+(1.0/3.0))))"), (PrettyP, Seq.empty)), ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J5.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J5.scala index 455a7785..6e9032cd 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J5.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J5.scala @@ -1,7 +1,11 @@ package org.combinators.ep.domain.math.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Add, AddInst, LitInst, addi} import org.combinators.ep.domain.math.M5 import org.combinators.ep.domain.math.systemJ.J3.all_instances @@ -10,7 +14,7 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J5 extends Evolution { override implicit def getModel: GenericModel = J4.getModel.evolve("j5", Seq.empty, Seq(Equals)) - lazy val Equals = Operation("equal_to", TypeRep.Boolean, Seq(Parameter("other", TypeRep.DataType(M5.getModel.baseDataType)))) + lazy val Equals: Operation = Operation("equal_to", TypeRep.Boolean, Seq(Parameter("other", DomainTpeRep.DataType(M5.getModel.baseDataType)))) object EqualsBinaryMethodTestCase { def apply(op: Operation, instance: DataTypeInstance, instance1: DataTypeInstance, result: Boolean): TestCase = { @@ -19,7 +23,7 @@ object J5 extends Evolution { instance, op, InstanceRep(TypeRep.Boolean)(result), - InstanceRep.apply(instance1)(getModel) + DataTypeInstanceRep.apply(instance1)(getModel) ) } } @@ -57,13 +61,13 @@ object J5 extends Evolution { addi, // first, base instance // initial parameter to use when testing equals - Seq(InstanceRep(AddInst(LitInst(1.0), LitInst(2.0)))), + Seq(DataTypeInstanceRep(AddInst(LitInst(1.0), LitInst(2.0)))), // function tells how InstanceRep parameters evolve with each iteration // Seq[InstanceRep] => Seq[InstanceRep] params => params.map(param => param.inst match { - case i: InstanceRep => InstanceRep(DataTypeInstance(Add, Seq(i, i))) + case i: InstanceRep => DataTypeInstanceRep(DataTypeInstance(Add, Seq(i, i))) case _ => param }), diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J6.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J6.scala index 7842de05..d1b9fd2b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J6.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJ/J6.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemJ /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.{DataTypeInstance, DataTypeInstanceRep} import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.systemJ.J1.SubInst import org.combinators.ep.domain.math.systemJ.J2.MultInst @@ -11,15 +13,13 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J6 extends Evolution { override implicit def getModel: GenericModel = J5.getModel.evolve("j6", Seq.empty, Seq(PowBy)) - // m7:model evolution. - // ------------------- object j8_extensions { val target = "target" } // add PowBy operation - lazy val base = TypeRep.DataType(J3.getModel.baseDataType) - lazy val PowBy = Operation("powBy", base, Seq(Parameter("other", base))) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(J3.getModel.baseDataType) + lazy val PowBy: Operation = Operation("powBy", base, Seq(Parameter("other", base))) object PowByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected: InstanceRep): TestCase = { @@ -28,27 +28,27 @@ object J6 extends Evolution { } } - val m7_2 = AddInst(LitInst(1.0), LitInst(2.0)) - val m7_3 = AddInst(LitInst(1.0), LitInst(2.0)) - val m7_4 = AddInst(m7_2, m7_3) + val m7_2: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val m7_3: DataTypeInstance = AddInst(LitInst(1.0), LitInst(2.0)) + val m7_4: DataTypeInstance = AddInst(m7_2, m7_3) - val m7_5 = AddInst(LitInst(99.0), LitInst(2.0)) - val m7_6 = AddInst(LitInst(99.0), LitInst(2.0)) - val m7_7 = AddInst(m7_5, m7_6) + val m7_5: DataTypeInstance = AddInst(LitInst(99.0), LitInst(2.0)) + val m7_6: DataTypeInstance = AddInst(LitInst(99.0), LitInst(2.0)) + val m7_7: DataTypeInstance = AddInst(m7_5, m7_6) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(J5) def tests: Seq[TestCase] = Seq( PowByTestCase(AddInst(LitInst(1.0), LitInst(12.0)), - InstanceRep(LitInst(4.0)), DoubleInst(13.0 * 13.0 * 13.0 * 13.0)), + DataTypeInstanceRep(LitInst(4.0)), DoubleInst(13.0 * 13.0 * 13.0 * 13.0)), PowByTestCase(LitInst(12.0), - InstanceRep(LitInst(0.0)), DoubleInst(1.0)), + DataTypeInstanceRep(LitInst(0.0)), DoubleInst(1.0)), - PowByTestCase(SubInst(LitInst(13.0), LitInst(5.0)), InstanceRep(LitInst(4.0)), DoubleInst(8.0 * 8.0 * 8.0 * 8.0)), - PowByTestCase(LitInst(4.0), InstanceRep(LitInst(-1.0)), DoubleInst(0.25)), - PowByTestCase(DivdInst(LitInst(4.0), LitInst(2.0)), InstanceRep(LitInst(4.0)), DoubleInst(2.0 * 2.0 * 2.0 * 2.0)), - PowByTestCase(MultInst(LitInst(4.0), LitInst(2.0)), InstanceRep(LitInst(4.0)), DoubleInst(8.0 * 8.0 * 8.0 * 8.0)), - PowByTestCase(NegInst(LitInst(2.0)), InstanceRep(LitInst(4.0)), DoubleInst((-2.0) * (-2.0) * (-2.0) * (-2.0))) + PowByTestCase(SubInst(LitInst(13.0), LitInst(5.0)), DataTypeInstanceRep(LitInst(4.0)), DoubleInst(8.0 * 8.0 * 8.0 * 8.0)), + PowByTestCase(LitInst(4.0), DataTypeInstanceRep(LitInst(-1.0)), DoubleInst(0.25)), + PowByTestCase(DivdInst(LitInst(4.0), LitInst(2.0)), DataTypeInstanceRep(LitInst(4.0)), DoubleInst(2.0 * 2.0 * 2.0 * 2.0)), + PowByTestCase(MultInst(LitInst(4.0), LitInst(2.0)), DataTypeInstanceRep(LitInst(4.0)), DoubleInst(8.0 * 8.0 * 8.0 * 8.0)), + PowByTestCase(NegInst(LitInst(2.0)), DataTypeInstanceRep(LitInst(4.0)), DoubleInst((-2.0) * (-2.0) * (-2.0) * (-2.0))) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J7.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J7.scala index 4d670112..5ed69e5b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J7.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J7.scala @@ -1,10 +1,12 @@ package org.combinators.ep.domain.math.systemJK /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{DoubleInst, Eval, LitInst} import org.combinators.ep.domain.{Evolution, GenericModel} -import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, EqualsTestCase, TestCase} +import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, EqualsTestCase} import org.combinators.ep.domain.math.systemJ.J1.MultBy import org.combinators.ep.domain.math.{M0, MathDomain} import org.combinators.ep.domain.math.systemJ.J2 @@ -17,19 +19,19 @@ import org.combinators.ep.domain.math.systemK.K2.{Collect, ListDoubleInst, Simpl object J7 extends Evolution { override implicit def getModel: GenericModel = K2J6.getModel.evolve("j7", Seq(Inv), J2.isOps(Seq(Inv))) - lazy val Inv = DataTypeCase.binary("Inv")(MathDomain.getModel) + lazy val Inv: DataTypeCase = DataTypeCase.binary("Inv")(MathDomain.getModel) def InvInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Inv, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Inv, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) - val invi = InvInst(LitInst(3.0), LitInst(5.0)) + val invi: DataTypeInstance = InvInst(LitInst(3.0), LitInst(5.0)) - val invi_same_lhs = InvInst(LitInst(3.0), LitInst(4.0)) - val invi_same_rhs = InvInst(LitInst(4.0), LitInst(5.0)) + val invi_same_lhs: DataTypeInstance = InvInst(LitInst(3.0), LitInst(4.0)) + val invi_same_rhs: DataTypeInstance = InvInst(LitInst(4.0), LitInst(5.0)) - val all_instances = K2J6.all_instances ++ Seq(invi) - val lhs = K2J6.lhs ++ Seq(invi_same_lhs) // changes on left hand side - val rhs = K2J6.rhs ++ Seq(invi_same_rhs) // changes on right hand side + val all_instances: Seq[DataTypeInstance] = K2J6.all_instances ++ Seq(invi) + val lhs: Seq[DataTypeInstance] = K2J6.lhs ++ Seq(invi_same_lhs) // changes on left hand side + val rhs: Seq[DataTypeInstance] = K2J6.rhs ++ Seq(invi_same_rhs) // changes on right hand side override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(K2J6) @@ -44,18 +46,18 @@ object J7 extends Evolution { EqualsCompositeTestCase(getModel.baseDataType, invi, StringInst("(5.0/3.0)"), (Simplify, Seq.empty), (PrettyP, Seq.empty)), // these are not possible in SOME EP implementations, because of 'equals' being used. - // EqualsTestCase(getModel.baseDataType, InvInst(LitInst(2.0), LitInst(4.0)), PowBy, InstanceRep(PowerInst(InvInst(LitInst(2.0), LitInst(4.0)), LitInst(3.0))), - // InstanceRep(LitInst(3.0))), - // EqualsTestCase(getModel.baseDataType, MultInst(LitInst(2.0), LitInst(4.0)), PowBy, InstanceRep(PowerInst(MultInst(LitInst(2.0), LitInst(4.0)), LitInst(3.0))), - // InstanceRep(LitInst(3.0))), - // EqualsTestCase(getModel.baseDataType, InvInst(LitInst(2.0), LitInst(4.0)), MultBy, InstanceRep(MultInst(InvInst(LitInst(2.0), LitInst(4.0)), LitInst(6.0))), - // InstanceRep(LitInst(6.0))), + // EqualsTestCase(getModel.baseDataType, InvInst(LitInst(2.0), LitInst(4.0)), PowBy, DataTypeInstanceRep(PowerInst(InvInst(LitInst(2.0), LitInst(4.0)), LitInst(3.0))), + // DataTypeInstanceRep(LitInst(3.0))), + // EqualsTestCase(getModel.baseDataType, MultInst(LitInst(2.0), LitInst(4.0)), PowBy, DataTypeInstanceRep(PowerInst(MultInst(LitInst(2.0), LitInst(4.0)), LitInst(3.0))), + // DataTypeInstanceRep(LitInst(3.0))), + // EqualsTestCase(getModel.baseDataType, InvInst(LitInst(2.0), LitInst(4.0)), MultBy, DataTypeInstanceRep(MultInst(InvInst(LitInst(2.0), LitInst(4.0)), LitInst(6.0))), + // DataTypeInstanceRep(LitInst(6.0))), // do this instead - EqualsCompositeTestCase(getModel.baseDataType, InvInst(LitInst(3.0), LitInst(6.0)), DoubleInst(6.0), (MultBy, Seq(InstanceRep(LitInst(3.0)))), (Eval, Seq.empty)), + EqualsCompositeTestCase(getModel.baseDataType, InvInst(LitInst(3.0), LitInst(6.0)), DoubleInst(6.0), (MultBy, Seq(DataTypeInstanceRep(LitInst(3.0)))), (Eval, Seq.empty)), EqualsTestCase(getModel.baseDataType, invi, Collect, ListDoubleInst(Seq(3.0, 5.0))), - PowByTestCase(InvInst(LitInst(4.0), LitInst(2.0)), InstanceRep(LitInst(4.0)), DoubleInst(0.5 * 0.5 * 0.5 * 0.5)), + PowByTestCase(InvInst(LitInst(4.0), LitInst(2.0)), DataTypeInstanceRep(LitInst(4.0)), DoubleInst(0.5 * 0.5 * 0.5 * 0.5)), ) ++ eqls(all_instances) ++ not_eqls(all_instances) ++ struct_not_eqls(all_instances, lhs, rhs) ++ op_equals(all_instances) ++ op_not_equals(all_instances) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J8.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J8.scala index c1e8b49f..02cd0311 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J8.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/J8.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemJK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{EqualsTestCase, Operation, TestCase, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.{TestCase, TypeRep} +import org.combinators.ep.domain.abstractions.{EqualsTestCase, Operation} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, LitInst} import org.combinators.ep.domain.math.systemJ.J1.SubInst import org.combinators.ep.domain.math.systemJ.J2.MultInst @@ -13,7 +15,7 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object J8 extends Evolution { override implicit def getModel: GenericModel = J7.getModel.evolve("j8", Seq.empty, Seq(Height)) - lazy val Height = Operation("height", TypeRep.Int, Seq.empty) + lazy val Height: Operation = Operation("height", TypeRep.Int, Seq.empty) // m9_3 <-- m9_3 has height of 3 // / \ @@ -24,23 +26,23 @@ object J8 extends Evolution { // m9_0 m9_0 <-- height(s) of 0 // // and also do right-leaning... - val m9_0 = LitInst(2.0) - val m9_1 = AddInst(m9_0, m9_0) - val m9_2 = SubInst(m9_0, m9_1) - val m9_3 = DivdInst(m9_0, m9_2) - val m9_1r = AddInst(m9_0, m9_0) - val m9_2r = SubInst(m9_0, m9_1r) - val m9_3r = DivdInst(m9_2r, m9_0) + val m9_0: DataTypeInstance = LitInst(2.0) + val m9_1: DataTypeInstance = AddInst(m9_0, m9_0) + val m9_2: DataTypeInstance = SubInst(m9_0, m9_1) + val m9_3: DataTypeInstance = DivdInst(m9_0, m9_2) + val m9_1r: DataTypeInstance = AddInst(m9_0, m9_0) + val m9_2r: DataTypeInstance = SubInst(m9_0, m9_1r) + val m9_3r: DataTypeInstance = DivdInst(m9_2r, m9_0) - val ma_1 = InvInst(m9_0, m9_0) - val ma_2 = MultInst(m9_0, ma_1) - val ma_3 = DivdInst(m9_0, ma_2) - val ma_4 = NegInst(ma_3) - val ma_5 = PowerInst(ma_4, ma_4) - val ma_2r = MultInst(m9_0, ma_1) - val ma_3r = DivdInst(m9_0, ma_2r) - val ma_4r = NegInst(ma_3r) - val ma_5r = PowerInst(ma_4r, ma_4r) + val ma_1: DataTypeInstance = InvInst(m9_0, m9_0) + val ma_2: DataTypeInstance = MultInst(m9_0, ma_1) + val ma_3: DataTypeInstance = DivdInst(m9_0, ma_2) + val ma_4: DataTypeInstance = NegInst(ma_3) + val ma_5: DataTypeInstance = PowerInst(ma_4, ma_4) + val ma_2r: DataTypeInstance = MultInst(m9_0, ma_1) + val ma_3r: DataTypeInstance = DivdInst(m9_0, ma_2r) + val ma_4r: DataTypeInstance = NegInst(ma_3r) + val ma_5r: DataTypeInstance = PowerInst(ma_4r, ma_4r) def IntInst(i: scala.Int): InstanceRep = InstanceRep(TypeRep.Int)(i) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/K2J6.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/K2J6.scala index 44d2b491..b3e3d418 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/K2J6.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemJK/K2J6.scala @@ -1,7 +1,8 @@ package org.combinators.ep.domain.math.systemJK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.ep.domain.instances.{DataTypeInstance, DataTypeInstanceRep} +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{EqualsCompositeTestCase, EqualsTestCase} import org.combinators.ep.domain.math.M0 import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, Lit, LitInst, addi, liti} import org.combinators.ep.domain.math.systemJ.J1.subi @@ -19,11 +20,11 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object K2J6 extends Evolution { override implicit def getModel: GenericModel = J6.getModel.merge("k2j6", Seq.empty, Seq.empty, Seq(K2.getModel)) - val all_instances = J3.all_instances ++ Seq(powi) - val lhs = J3.lhs ++ Seq(powi_same_lhs) // changes on left hand side - val rhs = J3.rhs ++ Seq(powi_same_rhs) // changes on right hand side + val all_instances: Seq[DataTypeInstance] = J3.all_instances ++ Seq(powi) + val lhs: Seq[DataTypeInstance] = J3.lhs ++ Seq(powi_same_lhs) // changes on left hand side + val rhs: Seq[DataTypeInstance] = J3.rhs ++ Seq(powi_same_rhs) // changes on right hand side - val tree_node = Node(Divd.name.hashCode, + val tree_node:Node = Node(Divd.name.hashCode, Seq( Node(Lit.name.hashCode, Seq(Leaf(DoubleInst(1.0)))), Node(Lit.name.hashCode, Seq(Leaf(DoubleInst(3.0)))) @@ -42,10 +43,10 @@ object K2J6 extends Evolution { // in CoCo this leads to an invocation of .equals which defaults to java.lang.equals, so this won't work in some approaches that rely on default // implementations in interfaces, which will take second place to default java.lang.Object#equals. Works for OO-Traditional; breaks for Coco. - // EqualsTestCase(getModel.baseDataType, PowerInst(LitInst(2.0), LitInst(3.0)), PowBy, InstanceRep(PowerInst(PowerInst(LitInst(2.0), LitInst(3.0)), LitInst(2.0))), - // InstanceRep(LitInst(2.0))), // 8^2 == 64 + // EqualsTestCase(getModel.baseDataType, PowerInst(LitInst(2.0), LitInst(3.0)), PowBy, DataTypeInstanceRep(PowerInst(PowerInst(LitInst(2.0), LitInst(3.0)), LitInst(2.0))), + // DataTypeInstanceRep(LitInst(2.0))), // 8^2 == 64 // Use This Instead as a substitute for above - EqualsCompositeTestCase(getModel.baseDataType, PowerInst(LitInst(2.0), LitInst(3.0)), DoubleInst(64.0), (PowBy, Seq(InstanceRep(LitInst(2.0)))), (Eval, Seq.empty)), + EqualsCompositeTestCase(getModel.baseDataType, PowerInst(LitInst(2.0), LitInst(3.0)), DoubleInst(64.0), (PowBy, Seq(DataTypeInstanceRep(LitInst(2.0)))), (Eval, Seq.empty)), EqualsCompositeTestCase(getModel.baseDataType, DivdInst(LitInst(5.0), LitInst(5.0)), DoubleInst(1.0), (Simplify, Seq.empty), (Eval, Seq.empty)), EqualsCompositeTestCase(getModel.baseDataType, DivdInst(LitInst(5.0), LitInst(1.0)), DoubleInst(5.0), (Simplify, Seq.empty), (Eval, Seq.empty)), @@ -63,7 +64,7 @@ object K2J6 extends Evolution { // Cannot write a test case like this, because Boolean is not in the domain! We could seek to add it as a type (whose eval is 0.0 or 1.0) // EqualsCompositeTestCase(getModel.baseDataType, DivdInst(LitInst(5.0), LitInst(5.0)), DoubleInst(1.0), - // (Simplify, Seq.empty), (Eql, Seq(InstanceRep(LitInst(1.0)))), (Eval, Seq.empty)), + // (Simplify, Seq.empty), (Eql, Seq(DataTypeInstanceRep(LitInst(1.0)))), (Eval, Seq.empty)), ) ++ eqls(all_instances) ++ not_eqls(all_instances) ++ struct_not_eqls(all_instances, lhs, rhs) ++ op_equals(all_instances) ++ op_not_equals(all_instances) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K1.scala index f9e00a06..280b614e 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K1.scala @@ -1,7 +1,9 @@ package org.combinators.ep.domain.math.systemK /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.MathDomain import org.combinators.ep.domain.math.systemJ.J1.MultByTestCase @@ -15,23 +17,22 @@ object K1 extends Evolution { lazy val Power: DataTypeCase = DataTypeCase.binary("Power")(MathDomain.getModel) def PowerInst(base: DataTypeInstance, exponent: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Power, Seq(InstanceRep(base), InstanceRep(exponent))) + DataTypeInstance(Power, Seq(DataTypeInstanceRep(base), DataTypeInstanceRep(exponent))) - val powi = PowerInst(LitInst(3.0), LitInst(5.0)) + val powi: DataTypeInstance = PowerInst(LitInst(3.0), LitInst(5.0)) - val powi_same_lhs = PowerInst(LitInst(3.0), LitInst(4.0)) - val powi_same_rhs = PowerInst(LitInst(4.0), LitInst(5.0)) + val powi_same_lhs: DataTypeInstance = PowerInst(LitInst(3.0), LitInst(4.0)) + val powi_same_rhs: DataTypeInstance = PowerInst(LitInst(4.0), LitInst(5.0)) - val all_instances = J2.all_instances ++ Seq(powi) - val lhs = J2.lhs ++ Seq(powi_same_lhs) // changes on left hand side - val rhs = J2.rhs ++ Seq(powi_same_rhs) // changes on right hand side + val all_instances: Seq[DataTypeInstance] = J2.all_instances ++ Seq(powi) + val lhs: Seq[DataTypeInstance] = J2.lhs ++ Seq(powi_same_lhs) // changes on left hand side + val rhs: Seq[DataTypeInstance] = J2.rhs ++ Seq(powi_same_rhs) // changes on right hand side override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(J2) - def tests: Seq[TestCase] = Seq( EqualsTestCase(getModel.baseDataType, PowerInst(LitInst(2.0), LitInst(5.0)), Eval, DoubleInst(32.0)), - MultByTestCase(powi, InstanceRep(LitInst(3.0)), DoubleInst(729.0)), + MultByTestCase(powi, DataTypeInstanceRep(LitInst(3.0)), DoubleInst(729.0)), ) ++ eqls(all_instances) ++ not_eqls(all_instances) ++ struct_not_eqls(all_instances, lhs, rhs) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K2.scala index a9a86682..2343482a 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemK/K2.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemK /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, Eval, LitInst, addi} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.M3.MultInst @@ -15,23 +18,23 @@ object K2 extends Evolution { override implicit def getModel: GenericModel = K1.getModel.evolve("k2", Seq.empty, Seq(Simplify, Collect)) // this is a producer method (as you can tell by its return type). - lazy val Simplify = Operation("simplify", TypeRep.DataType(MathDomain.getModel.baseDataType)) + lazy val Simplify: Operation = Operation("simplify", DomainTpeRep.DataType(MathDomain.getModel.baseDataType)) def ListDoubleInst(doubles: Seq[scala.Double]): InstanceRep = InstanceRep(TypeRep.Sequence(TypeRep.Double))(doubles) - lazy val Collect = Operation("collect", TypeRep.Sequence(TypeRep.Double)) + lazy val Collect: Operation = Operation("collect", TypeRep.Sequence(TypeRep.Double)) - val m4_m2 = MultInst(LitInst(2.0), LitInst(3.0)) + val m4_m2: DataTypeInstance = MultInst(LitInst(2.0), LitInst(3.0)) - val m4_s_5 = AddInst(LitInst(5.0), LitInst(0.0)) - val m4_s_00 = AddInst(LitInst(0.0), LitInst(0.0)) - val m4_s_7 = AddInst(LitInst(0.0), LitInst(7.0)) + val m4_s_5: DataTypeInstance = AddInst(LitInst(5.0), LitInst(0.0)) + val m4_s_00: DataTypeInstance = AddInst(LitInst(0.0), LitInst(0.0)) + val m4_s_7: DataTypeInstance = AddInst(LitInst(0.0), LitInst(7.0)) // validates simplify ((5+0)+(0+7)) = (5+7) - val m4_together = AddInst(m4_s_5, m4_s_7) - val m4_s_13 = MultInst(LitInst(13.0), LitInst(1.0)) - val m4_s_12 = MultInst(LitInst(1.0), LitInst(12.0)) - val m4_s_m0 = SubInst(LitInst(7.0), LitInst(7.0)) + val m4_together: DataTypeInstance = AddInst(m4_s_5, m4_s_7) + val m4_s_13: DataTypeInstance = MultInst(LitInst(13.0), LitInst(1.0)) + val m4_s_12: DataTypeInstance = MultInst(LitInst(1.0), LitInst(12.0)) + val m4_s_m0: DataTypeInstance = SubInst(LitInst(7.0), LitInst(7.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(K1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1.scala index 1c3d002d..10f9fd5b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1.scala @@ -1,11 +1,12 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.{Tag, TestCase} import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.instances.DataTypeInstance -import org.combinators.ep.domain.math.M0.{Eval, LitInst} -import org.combinators.ep.domain.math.{M1, M2} -import org.combinators.ep.domain.math.M2.{PrettyP, StringInst, getModel} +import org.combinators.ep.domain.math.M0.LitInst +import org.combinators.ep.domain.math.M2 +import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} /** * Provides a corrective implementation for PrettyP/Lit by "doubling" the output. Note that any optimization diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1OA.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1OA.scala index d04972e4..6e6405a8 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1OA.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O1OA.scala @@ -1,9 +1,8 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.math.M2 -import org.combinators.ep.domain.math.systemO.O1.allPastTests /** * Combines together two different evolutions, each of which has an independent Op/TypeCase whose implementation diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O2.scala index 1d6261ff..33ce1417 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/O2.scala @@ -1,5 +1,6 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.instances.DataTypeInstance diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OA.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OA.scala index 290b6d06..f9532977 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OA.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OA.scala @@ -1,11 +1,11 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.M2 -import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} /** * Provides a corrective implementation for Eval/Lit though there is no visible different in output. @@ -16,7 +16,6 @@ object OA extends Evolution { .optimize(Set((math.M0.Lit,math.M0.Eval))) // this optimization has no external impact, so it is fine to allow default test impl - val oa: DataTypeInstance = LitInst(1.0) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M2) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD1.scala index df5dde0c..353002df 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD1.scala @@ -1,8 +1,10 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.LitInst import org.combinators.ep.domain.math.{M2, MathDomain} import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} @@ -13,7 +15,7 @@ object OD1 extends Evolution { lazy val Mult: DataTypeCase = DataTypeCase.binary("Mult")(MathDomain.getModel) def MultInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Mult, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Mult, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) val od1: DataTypeInstance = MultInst(LitInst(2.0), LitInst(3.0)) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD2.scala index 18022de0..906cfa18 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD2.scala @@ -1,8 +1,10 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.LitInst import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} import org.combinators.ep.domain.math.{M2, MathDomain} @@ -13,7 +15,7 @@ object OD2 extends Evolution { lazy val Divd: DataTypeCase = DataTypeCase.binary("Divd")(MathDomain.getModel) def DivdInst(left:DataTypeInstance, right:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Divd, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Divd, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) val od2: DataTypeInstance = DivdInst(LitInst(2.0), LitInst(3.0)) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD3.scala index 33e17f2c..857e3c18 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OD3.scala @@ -1,11 +1,7 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} -import org.combinators.ep.domain.math.M0.LitInst -import org.combinators.ep.domain.math.M2.{PrettyP, StringInst} -import org.combinators.ep.domain.math.{M2, MathDomain} object OD3 extends Evolution { override implicit def getModel:GenericModel = OD2.getModel.extend("od3", Seq(OD1.getModel)) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO1.scala index 506411b1..80dfc88d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO1.scala @@ -1,8 +1,11 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, LitInst} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.M2 @@ -12,7 +15,7 @@ object OO1 extends Evolution { def StringInst(s:String): InstanceRep = InstanceRep(TypeRep.String)(s) - lazy val Atomic = Operation("atomic", TypeRep.String) + lazy val Atomic: Operation = Operation("atomic", TypeRep.String) // Tests val oo1_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(2.0)) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO2.scala index c931e9f8..4b8d29dc 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO2.scala @@ -1,8 +1,11 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, LitInst} import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.M2 diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO3.scala index 70f7c990..5d237279 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemO/OO3.scala @@ -1,14 +1,13 @@ package org.combinators.ep.domain.math.systemO /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions._ object OO3 extends Evolution { override implicit def getModel:GenericModel = OO2.getModel.extend("oo3", Seq(OO1.getModel)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(OO2) - // testing def tests: Seq[TestCase] = Seq( ) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X1.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X1.scala index d1580a60..53d0f68b 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X1.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X1.scala @@ -1,7 +1,11 @@ package org.combinators.ep.domain.math.systemX /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{AddInst, DoubleInst, Eval, LitInst} import org.combinators.ep.domain.math.M2.StringInst import org.combinators.ep.domain.math.{M0, MathDomain} @@ -10,13 +14,11 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object X1 extends Evolution { override implicit def getModel: GenericModel = M0.getModel.evolve("x1", Seq(Sub), Seq(PrettyP, MultBy)) - lazy val base = TypeRep.DataType(M0.getModel.baseDataType) + lazy val base: DomainTpeRep.DataType = DomainTpeRep.DataType(M0.getModel.baseDataType) - // x1:model evolution. - // ------------------- lazy val Sub: DataTypeCase = DataTypeCase.binary("Sub")(MathDomain.getModel) - lazy val PrettyP = Operation("prettyp", TypeRep.String) - lazy val MultBy = Operation("multBy", base, Seq(Parameter("other", base))) + lazy val PrettyP: Operation = Operation("prettyp", TypeRep.String) + lazy val MultBy: Operation = Operation("multBy", base, Seq(Parameter("other", base))) object MultByTestCase { def apply(instance: DataTypeInstance, argument: InstanceRep, expected: InstanceRep): TestCase = { @@ -26,10 +28,10 @@ object X1 extends Evolution { } // Tests - val m2_s1 = SubInst(LitInst(1.0), LitInst(2.0)) + val m2_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(2.0)) def SubInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Sub, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Sub, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(M0) @@ -43,10 +45,10 @@ object X1 extends Evolution { PrettyP, StringInst("((1.0-2.0)+(5.0+6.0))")), MultByTestCase(AddInst(LitInst(1.0), LitInst(2.0)), - InstanceRep(LitInst(3.0)), DoubleInst(9.0)), + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(9.0)), MultByTestCase(LitInst(2.0), - InstanceRep(LitInst(0.0)), DoubleInst(0.0)), + DataTypeInstanceRep(LitInst(0.0)), DoubleInst(0.0)), MultByTestCase(LitInst(0.0), - InstanceRep(LitInst(3.0)), DoubleInst(0.0)) + DataTypeInstanceRep(LitInst(3.0)), DoubleInst(0.0)) ) } diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2.scala index 9e7481f1..22209b6d 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.{TestCase, TypeRep} +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.{M0, MathDomain} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -11,13 +14,13 @@ object X2 extends Evolution { def StringInst(s: String): InstanceRep = InstanceRep(TypeRep.String)(s) - lazy val Times = DataTypeCase.binary("Times")(MathDomain.getModel) + lazy val Times: DataTypeCase = DataTypeCase.binary("Times")(MathDomain.getModel) def TimesInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Times, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Times, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val x2_1 = TimesInst(LitInst(3.0), LitInst(2.0)) + val x2_1: DataTypeInstance = TimesInst(LitInst(3.0), LitInst(2.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(X1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2X3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2X3.scala index be42a3f8..37c8ad3e 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2X3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X2X3.scala @@ -1,6 +1,6 @@ package org.combinators.ep.domain.math.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.TestCase +import org.combinators.cogen.TestCase import org.combinators.ep.domain.{Evolution, GenericModel} object X2X3 extends Evolution { diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X3.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X3.scala index d56e56ce..57af367f 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X3.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X3.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, TestCase, TypeRep} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.{TestCase, TypeRep} +import org.combinators.ep.domain.abstractions.DataTypeCase +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.LitInst import org.combinators.ep.domain.math.M1.SubInst import org.combinators.ep.domain.math.MathDomain @@ -12,13 +15,13 @@ object X3 extends Evolution { def StringInst(s: String): InstanceRep = InstanceRep(TypeRep.String)(s) - lazy val Divd = DataTypeCase.binary("Divd")(MathDomain.getModel) + lazy val Divd: DataTypeCase = DataTypeCase.binary("Divd")(MathDomain.getModel) def DivdInst(left: DataTypeInstance, right: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Divd, Seq(InstanceRep(left), InstanceRep(right))) + DataTypeInstance(Divd, Seq(DataTypeInstanceRep(left), DataTypeInstanceRep(right))) // Tests - val m2_s1 = SubInst(LitInst(1.0), LitInst(2.0)) + val m2_s1: DataTypeInstance = SubInst(LitInst(1.0), LitInst(2.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(X1) diff --git a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X4.scala b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X4.scala index 23d7bf87..43f874c0 100644 --- a/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X4.scala +++ b/domain/math/src/main/scala/org/combinators/ep/domain/math/systemX/X4.scala @@ -1,7 +1,10 @@ package org.combinators.ep.domain.math.systemX /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase, TestCase} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase +import org.combinators.ep.domain.abstractions.{DataTypeCase, EqualsTestCase} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.math.M0.{Eval, LitInst} import org.combinators.ep.domain.math.{M0, MathDomain} import org.combinators.ep.domain.{Evolution, GenericModel} @@ -9,13 +12,13 @@ import org.combinators.ep.domain.{Evolution, GenericModel} object X4 extends Evolution { override implicit def getModel: GenericModel = X2X3.getModel.evolve("x4", Seq(Neg), Seq.empty) - lazy val Neg = DataTypeCase.unary("Neg")(MathDomain.getModel) + lazy val Neg: DataTypeCase = DataTypeCase.unary("Neg")(MathDomain.getModel) def NegInst(inner: DataTypeInstance): DataTypeInstance = - DataTypeInstance(Neg, Seq(InstanceRep(inner))) + DataTypeInstance(Neg, Seq(DataTypeInstanceRep(inner))) // Tests - val x4_1 = NegInst(LitInst(5.0)) + val x4_1: DataTypeInstance = NegInst(LitInst(5.0)) override def allTests: Map[GenericModel, Seq[TestCase]] = allPastTests(X2X3) diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S0.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S0.scala index e470ce33..e4834eee 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S0.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S0.scala @@ -1,8 +1,12 @@ package org.combinators.ep.domain.shape /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.{EqualsTestCase, _} -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.abstractions._ +import org.combinators.ep.domain.instances.DataTypeInstance object S0 extends Evolution { @@ -17,7 +21,7 @@ object S0 extends Evolution { lazy val transx = Attribute("transx", TypeRep.Double) lazy val transy = Attribute("transy", TypeRep.Double) - lazy val shape = Attribute("shape", TypeRep.DataType(ShapeDomain.getModel.baseDataType)) + lazy val shape = Attribute("shape", DomainTpeRep.DataType(ShapeDomain.getModel.baseDataType)) val pointx = Parameter("pointx", TypeRep.Double) val pointy = Parameter("pointy", TypeRep.Double) @@ -37,7 +41,7 @@ object S0 extends Evolution { def PointInst(x:scala.Double, y:scala.Double): DataTypeInstance = DataTypeInstance(Circle, Seq(InstanceRep(TypeRep.Double)(x), InstanceRep(TypeRep.Double)(y))) def TranslateInst(transx:scala.Double, transy:scala.Double, shape:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Translate, Seq(InstanceRep(TypeRep.Double)(transx), InstanceRep(TypeRep.Double)(transy), InstanceRep(shape))) + DataTypeInstance(Translate, Seq(InstanceRep(TypeRep.Double)(transx), InstanceRep(TypeRep.Double)(transy), DataTypeInstanceRep(shape))) val sq1 = SquareInst(5.0) val c1 = CircleInst(5.0) @@ -61,8 +65,8 @@ object S0 extends Evolution { } def tests:Seq[TestCase] = Seq( - // EqualsTestCase(getModel.baseDataType, sq1, Unity, InstanceRep(TypeRep.Boolean)(true)), - // EqualsTestCase(getModel.baseDataType, sq1, ContainsPt, InstanceRep(TypeRep.Boolean)(true), DoubleInst(p1._1), DoubleInst(p1._2)), + // EqualsTestCase(getModel.baseDataType, sq1, Unity, DataTypeInstanceRep(TypeRep.Boolean)(true)), + // EqualsTestCase(getModel.baseDataType, sq1, ContainsPt, DataTypeInstanceRep(TypeRep.Boolean)(true), DoubleInst(p1._1), DoubleInst(p1._2)), // NotEqualsTestCase(getModel.baseDataType, c1, ContainsPt, TRUE, p2._1, p2._2), ContainsTestCase(sq1, p1, result=true), diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S1.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S1.scala index 67685ebd..36278c8d 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S1.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S1.scala @@ -1,21 +1,22 @@ package org.combinators.ep.domain.shape /*DD:LI:AI*/ - +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} +import org.combinators.ep.domain.instances.DataTypeInstance import org.combinators.ep.domain.shape.S0._ object S1 extends Evolution { override implicit def getModel:GenericModel = S0.getModel.evolve("s1", Seq(Union), Seq.empty) - lazy val s1 = Attribute("s1", TypeRep.DataType(ShapeDomain.getModel.baseDataType)) - lazy val s2 = Attribute("s2", TypeRep.DataType(ShapeDomain.getModel.baseDataType)) + lazy val s1 = Attribute("s1", DomainTpeRep.DataType(ShapeDomain.getModel.baseDataType)) + lazy val s2 = Attribute("s2", DomainTpeRep.DataType(ShapeDomain.getModel.baseDataType)) lazy val Union = DataTypeCase("Union", Seq(s1, s2)) def UnionInst(i1:DataTypeInstance, i2:DataTypeInstance): DataTypeInstance = - DataTypeInstance(Union, Seq(InstanceRep(i1), InstanceRep(i2))) + DataTypeInstance(Union, Seq(DataTypeInstanceRep(i1), DataTypeInstanceRep(i2))) // point IN circle but not in SQUARE [radius = 5 val p3 = (3.0, 3.0) diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S2.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S2.scala index 60e15afd..b1ac8eb6 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S2.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/S2.scala @@ -1,8 +1,10 @@ package org.combinators.ep.domain.shape /*DD:LI:AI*/ +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.InstanceRep import org.combinators.ep.domain.shape.S0.ContainsTestCase object S2 extends Evolution { @@ -14,7 +16,7 @@ object S2 extends Evolution { // for the EIPs. This is a producer method. val pct = Parameter("pct", TypeRep.Double) lazy val Shrink = Operation("shrink", - TypeRep.DataType(ShapeDomain.getModel.baseDataType), Seq(Parameter("pct", TypeRep.Double))) + DomainTpeRep.DataType(ShapeDomain.getModel.baseDataType), Seq(Parameter("pct", TypeRep.Double))) def DoubleInst(d: scala.Double): InstanceRep = InstanceRep(TypeRep.Double)(d) diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/ShapeDomain.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/ShapeDomain.scala index 45c669ce..a75f850e 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/ShapeDomain.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/ShapeDomain.scala @@ -1,7 +1,7 @@ package org.combinators.ep.domain.shape /*DD:LI:AI*/ +import org.combinators.cogen.TestCase import org.combinators.ep.domain._ -import org.combinators.ep.domain.abstractions.TestCase /** * Shape domain as suitable for diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S0.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S0.scala index 63cbf574..d08587dd 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S0.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S0.scala @@ -1,13 +1,15 @@ package org.combinators.ep.domain.shape.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.InstanceRep +import org.combinators.ep.domain.instances.DataTypeInstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans, RealArithmetic, Strings} +import org.combinators.ep.domain.abstractions.Operation +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.domain.{GenericModel, shape} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans, RealArithmetic, Strings} /** * Truly language independent abstractions. Since we are in the mathematical domain, the diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S1.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S1.scala index 520460ee..097206af 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S1.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S1.scala @@ -1,12 +1,13 @@ package org.combinators.ep.domain.shape.eips /*DD:LI:AI*/ + +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans} import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, shape} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans} object S1 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] diff --git a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S2.scala b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S2.scala index 95f76bed..1e3cab3f 100644 --- a/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S2.scala +++ b/domain/shape/src/main/scala/org/combinators/ep/domain/shape/eips/S2.scala @@ -1,21 +1,22 @@ package org.combinators.ep.domain.shape.eips /*DD:LI:AI*/ -import org.combinators.ep.domain.abstractions.{Operation, TypeRep} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.AnyParadigm +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Booleans} +import org.combinators.ep.domain.abstractions.Operation import org.combinators.ep.domain.{GenericModel, shape} -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.generator.{ApproachImplementationProvider, EvolutionImplementationProvider} import org.combinators.ep.generator.EvolutionImplementationProvider.monoidInstance import org.combinators.ep.generator.communication.{PotentialRequest, ReceivedRequest, Request, SendRequest} -import org.combinators.ep.generator.paradigm.AnyParadigm -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Booleans} object S2 { def apply[P <: AnyParadigm, AIP[P <: AnyParadigm] <: ApproachImplementationProvider.WithParadigm[P]] (paradigm: P) (s1Provider: EvolutionImplementationProvider[AIP[paradigm.type]]) (ffiArithmetic: Arithmetic.WithBase[paradigm.MethodBodyContext, paradigm.type, Double], - ffiImper:Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type] + ffiImper:control.Imperative.WithBase[paradigm.MethodBodyContext, paradigm.type] ): EvolutionImplementationProvider[AIP[paradigm.type]] = { val s2Provider = new EvolutionImplementationProvider[AIP[paradigm.type]] { diff --git a/helloworld/README.txt b/helloworld/README.txt new file mode 100644 index 00000000..2a3629de --- /dev/null +++ b/helloworld/README.txt @@ -0,0 +1,5 @@ +Some rudimentary testing code is available + +00:01 sbt "helloWorld/runMain org.combinators.fibonacci.FibonacciWithLucasScalaDirectToDiskMain" + cd target/fib/scala +00:01 sbt test \ No newline at end of file diff --git a/helloworld/src/main/scala/ep/Base.scala b/helloworld/src/main/scala/ep/Base.scala deleted file mode 100644 index 66a45fb2..00000000 --- a/helloworld/src/main/scala/ep/Base.scala +++ /dev/null @@ -1,191 +0,0 @@ -/** - * Taken from http://infoscience.epfl.ch/record/52625 with upgrades for Scala "2.12.17" - * - * Doesn't work anymore - */ -package ep -trait Base { - - type exp <: Exp; - trait Exp { - def eval: Int - } - - class Num(v: Int) extends Exp { - val value:Int = v - def eval: Int = value - } -} - -object BaseTest extends Base with App { - type exp = Exp - val e: exp = new Num(7) - Console.println(e.eval) -} - -trait BasePlus extends Base { - class Plus(l: exp, r: exp) extends Exp { - val left:exp = l - val right:exp = r - def eval:Int = left.eval + right.eval - } -} -trait BaseNeg extends Base { - class Neg(t: exp) extends Exp { - val term:exp = t - def eval:Int = - term.eval - } -} - -trait BasePlusNeg extends BasePlus with BaseNeg; - -trait Show extends Base { - type exp <: Exp - trait Exp extends super.Exp { - def show: String - } - class Num(v: Int) extends super.Num(v) with Exp { - def show:String = value.toString - } -} - -trait ShowPlusNeg extends BasePlusNeg with Show { - class Plus(l: exp, r: exp) extends super.Plus(l, r) - with Exp { - def show:String = left.show + "+" + right.show - } - class Neg(t: exp) extends super.Neg(t) with Exp { - def show:String = "-(" + term.show + ")" - } -} - -object ShowPlusNegTest extends ShowPlusNeg with App { - type exp = Exp - val e: exp = new Neg(new Plus(new Num(7), new Num(6))) - Console.println(e.show + " = " + e.eval) -} - -trait DblePlusNeg extends BasePlusNeg { - type exp <: Exp; - trait Exp extends super.Exp { - def dble: exp; - } - def Num(v: Int): exp - def Plus(l: exp, r: exp): exp - def Neg(t: exp): exp - class Num(v: Int) extends super.Num(v) with Exp { - def dble:exp = Num(v * 2) - } - class Plus(l: exp, r: exp) - extends super.Plus(l, r) with Exp { - def dble:exp = Plus(left.dble, right.dble) - } - class Neg(t: exp) extends super.Neg(t) with Exp { - def dble:exp = Neg(t.dble) - } -} - -object DblePlusNegTest extends DblePlusNeg with App { - type exp = Exp - def Num(v: Int): exp = new Num(v) - def Plus(l: exp, r: exp): exp = new Plus(l, r) - def Neg(t: exp): exp = new Neg(t) - val e: exp = Plus(Neg(Plus(Num(1), Num(2))), Num(3)); - Console.println(e.dble.eval) -} - - -object erroneous { - val t1 = new ShowPlusNegTest.Num(1); - - // The commented code below is correct and taken from the paper. If you uncomment the definitions - // of 't2' and 't3' there will be a compilation error. - //val t2 = new DblePlusNegTest.Neg(t1); - // ^ - // type mismatch; - // found : ShowPlusNegTest.Num - // required: DblePlusNegTest.Exp - //val t3 = t1.dble; - // ^ - // value dble is not a member of - // ShowPlusNegTest.Num -} - -// DOES NOT WORK with Scala 2 -// -//trait ShowDblePlusNeg extends ShowPlusNeg -// with DblePlusNeg { -// type exp <: Exp; -// trait Exp extends super[ShowPlusNeg].Exp -// with super[DblePlusNeg].Exp; -// class Num(v: Int) -// extends super[ShowPlusNeg].Num(v) -// with super[DblePlusNeg].Num(v) with Exp -// class Plus(l: exp, r: exp) -// extends super[ShowPlusNeg].Plus(l, r) -// with super[DblePlusNeg].Plus(l, r) with Exp -// class Neg(t: exp) -// extends super[ShowPlusNeg].Neg(t) -// with super[DblePlusNeg].Neg(t) with Exp -//} - -trait Equals extends Base { - type exp <: Exp - trait Exp extends super.Exp { - def eql(other: exp): Boolean - def isNum(v: Int) = false - } - class Num(v: Int) extends super.Num(v) with Exp { - def eql(other: exp): Boolean = other.isNum(v) - override def isNum(v: Int) = v == value - } -} - -// had to modify to work -trait EqualsPlusNeg extends BasePlusNeg with Equals { - type exp <: Exp; - trait Exp extends super[BasePlusNeg].Exp - with super[Equals].Exp { - def isPlus(l: exp, r: exp): Boolean = false - def isNeg(t: exp): Boolean = false - } - class Num(v: Int) extends super[Equals].Num(v) - with Exp; - class Plus(l: exp, r: exp) extends super.Plus(l, r) with Exp { - def eql(other: exp): Boolean = other.isPlus(l, r) - override def isPlus(l: exp, r: exp) = - (left eql l) && (right eql r) - } - class Neg(t: exp) extends super.Neg(t) with Exp { - def eql(other: exp): Boolean = other.isNeg(t) - override def isNeg(t: exp) = term eql t - } -} - -/** Breaks down here... - -trait EqualsShowPlusNeg extends EqualsPlusNeg with ShowPlusNeg { - type exp <: Exp - trait Exp extends super[EqualsPlusNeg].Exp with super[ShowPlusNeg].Exp; - - class Num(v: Int) - extends super[EqualsPlusNeg].Num(v) with super[ShowPlusNeg].Num(v) with Exp - class Plus(l: exp, r: exp) - extends super[EqualsPlusNeg].Plus(l, r) - with super[ShowPlusNeg].Plus(l, r) with Exp - class Neg(term: exp) - extends super[EqualsPlusNeg].Neg(term) - with super[ShowPlusNeg].Neg(term) with Exp -} - -object EqualsShowPlusNegTest extends EqualsPlusNeg with App { - type exp = Exp; - val term1 = new Plus(new Num(1), new Num(2)); - val term2 = new Plus(new Num(1), new Num(2)); - val term3 = new Neg(new Num(2)); - Console.print(term1.show + "=" + term2.show + "? "); - Console.println(term1 eql term2); - Console.print(term1.show + "=" + term3.show + "? "); - Console.println(term1 eql term3); -} - **/ \ No newline at end of file diff --git a/helloworld/src/main/scala/ep/visitor/Visitor.scala b/helloworld/src/main/scala/ep/visitor/Visitor.scala deleted file mode 100644 index 275630b1..00000000 --- a/helloworld/src/main/scala/ep/visitor/Visitor.scala +++ /dev/null @@ -1,80 +0,0 @@ -/** - * Taken from http://infoscience.epfl.ch/record/52625 with upgrades for Scala "2.12.17" - * - * Doesn't work anymore - */ -package ep.visitor - -trait Base { - trait Exp { def accept(v: Visitor): Unit } - class Num(value: Int) extends Exp { - def accept(v: Visitor): Unit = v.visitNum(value) - } - - type visitor <: Visitor - trait Visitor { def visitNum(value: Int): Unit } - - class Eval extends Visitor { - var result: Int = _ - - def apply(t: Exp): Int = { - t.accept(this) - result - } - - def visitNum(value: Int): Unit = { result = value } - } -} - -object BaseTest extends Base with App { - type visitor = Visitor - val op: Eval = new Eval - - Console.println(op.apply(new Num(8))) -} - -/* -trait BasePlus extends Base { - type visitor <: Visitor - trait Visitor extends super.Visitor { - def visitPlus(left: Exp, right: Exp): Unit - } - class Plus(left: Exp, right: Exp) extends Exp { - def accept(v: Visitor): Unit = - v.visitPlus(left, right) - } - class Eval extends super.Eval with Visitor { - def visitPlus(l: Exp, r: Exp): Unit = { - result = apply(l) + apply(r) - } - } -}*/ -// -//trait BaseNeg extends Base { -// type visitor <: Visitor; -// trait Visitor extends super.Visitor { -// def visitNeg(term: Exp): Unit -// } -// class Neg(term: Exp) extends Exp { -// override def accept(v: visitor): Unit = // TYPO in paper -// v.visitNeg(term) -// } -// class Eval extends super.Eval with Visitor { -// def visitNeg(term: Exp): Unit = { -// result = -apply(term) -// } -// } -//} -// -//trait BasePlusNeg extends BasePlus with BaseNeg { -// type visitor <: Visitor -// trait Visitor extends super.Visitor with super[BaseNeg].Visitor -// class Eval extends super.Eval with super[BaseNeg].Eval with Visitor -//} -// -//object BasePlusNegTest extends BasePlusNeg { -// type visitor = Visitor -// val op: visitor = new Eval -// Console.println(op.apply( -// new Plus(new Num(1), new Neg(new Num(2))))); -//} \ No newline at end of file diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/Fibonacci.scala b/helloworld/src/main/scala/org/combinators/fibonacci/Fibonacci.scala index dc60840f..ad605579 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/Fibonacci.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/Fibonacci.scala @@ -1,10 +1,13 @@ package org.combinators.fibonacci -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Assertions, Equality} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.{AbstractSyntax, Command, NameProvider} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AnyParadigm, Functional} +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Assertions, Equality} +import org.combinators.cogen.Command +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.{AbstractSyntax, NameProvider} trait Fibonacci { val paradigm: AnyParadigm diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependent.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependent.scala index 3564bf0e..82baff42 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependent.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependent.scala @@ -1,10 +1,13 @@ package org.combinators.fibonacci -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Assertions, Equality} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, ObjectOriented, control} -import org.combinators.ep.generator.{AbstractSyntax, Command, NameProvider} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AnyParadigm, Functional, ObjectOriented} +import org.combinators.cogen.paradigm.control.Imperative +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Assertions, Equality} +import org.combinators.cogen.Command +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{NameProvider, AbstractSyntax} trait FibonacciIndependent { val paradigm: AnyParadigm @@ -155,7 +158,7 @@ object FibonacciIndependentProvider { (base: P) (nameProvider: NameProvider[base.syntax.Name], obj: ObjectOriented.WithBase[base.type], - c1: control.Imperative.WithBase[base.MethodBodyContext, base.type], + c1: Imperative.WithBase[base.MethodBodyContext, base.type], c2: Arithmetic.WithBase[base.MethodBodyContext, base.type, Int], c3: Assertions.WithBase[base.MethodBodyContext, base.type], c4: Equality.WithBase[base.MethodBodyContext, base.type], diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependentWithLucas.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependentWithLucas.scala index 0d439ca4..c70cff55 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependentWithLucas.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciIndependentWithLucas.scala @@ -1,10 +1,13 @@ package org.combinators.fibonacci -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Assertions, Equality} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, ObjectOriented, control} -import org.combinators.ep.generator.{AbstractSyntax, Command, NameProvider} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AnyParadigm, Functional, ObjectOriented} +import org.combinators.cogen.paradigm.control.Imperative +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Assertions, Equality} +import org.combinators.cogen.Command +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.{AbstractSyntax, NameProvider} trait FibonacciIndependentWithLucas { val paradigm: AnyParadigm @@ -250,7 +253,7 @@ object FibonacciIndependentWithLucasProvider { (base: P) (nameProvider: NameProvider[base.syntax.Name], obj: ObjectOriented.WithBase[base.type], - c1: control.Imperative.WithBase[base.MethodBodyContext, base.type], + c1: Imperative.WithBase[base.MethodBodyContext, base.type], c2: Arithmetic.WithBase[base.MethodBodyContext, base.type, Int], c3: Assertions.WithBase[base.MethodBodyContext, base.type], c4: Equality.WithBase[base.MethodBodyContext, base.type], diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainJava.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainJava.scala index 3da10e65..b581fd6a 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainJava.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainJava.scala @@ -20,8 +20,8 @@ package org.combinators.fibonacci import cats.effect.{ExitCode, IO, IOApp} import com.github.javaparser.ast.PackageDeclaration import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import FileWithPathPersistable._ import org.combinators.ep.language.java.paradigm.ObjectOriented import org.combinators.ep.language.java.{CodeGenerator, JavaNameProvider, PartiallyBoxed, Syntax} diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainRecursiveVariableScala.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainRecursiveVariableScala.scala index 3ac74e2d..f41dfe9e 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainRecursiveVariableScala.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainRecursiveVariableScala.scala @@ -24,9 +24,12 @@ package org.combinators.fibonacci import cats.effect.{ExitCode, IO, IOApp} import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} -import org.combinators.ep.language.scala.codegen.CodeGenerator +import org.combinators.cogen.FileWithPathPersistable.* +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import org.combinators.ep.language.scala.ast.ffi.* +import org.combinators.ep.language.scala.ast.{FinalBaseAST, FinalNameProviderAST} +import org.combinators.ep.language.scala.codegen.{CodeGenerator, FullAST} +import org.combinators.fibonacci.FibonacciRecursiveVariableProvider import java.nio.file.{Path, Paths} @@ -34,26 +37,43 @@ import java.nio.file.{Path, Paths} * Takes paradigm-independent specification for Fibonacci and generates Scala code */ class FibonacciRecursiveVariableMainScala { - val generator = CodeGenerator("fibonacci") + val ast: FullAST = new FinalBaseAST + with FinalNameProviderAST + with FinalArithmeticAST + with FinalAssertionsAST + with FinalBooleanAST + with FinalEqualsAST + with FinalListsAST + with FinalOperatorExpressionsAST + with FinalRealArithmeticOpsAST + with FinalStringAST { + val reificationExtensions = List.empty + } + + val emptyset: Set[Seq[FibonacciRecursiveVariableMainScala.this.ast.any.Name]] = Set.empty + val generator: CodeGenerator[ast.type] = CodeGenerator("fibonacci", ast, emptyset) // functional - val fibonacciApproach = FibonacciRecursiveVariableProvider[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl, generator.ints, generator.assertionsInMethod, generator.equality) + val fibonacciApproach = FibonacciRecursiveVariableProvider[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl.functionalControlInMethods, generator.ints.arithmeticInMethods, generator.assertions.assertionsInMethods, generator.equality.equalsInMethods) + + //[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl, generator.ints, generator.assertionsInMethod, generator.equality) // imperative // val fibonacciApproach = FibonacciIndependentProvider.imperative[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.ooParadigm, generator.imperative, generator.ints, generator.assertionsInMethod, generator.equality) - val persistable = FileWithPathPersistable[FileWithPath] + val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { val files = () => generator.paradigm.runGenerator { for { - _ <- generator.ints.enable() - _ <- generator.booleans.enable() - _ <- generator.strings.enable() - _ <- generator.equality.enable() - _ <- generator.assertionsInMethod.enable() + _ <- generator.ints.arithmeticInMethods.enable() + _ <- generator.booleans.booleansInMethodsInMethods.enable() + _ <- generator.strings.stringsInMethods.enable() + _ <- generator.equality.equalsInMethods.enable() + _ <- generator.assertions.assertionsInMethods.enable() + _ <- fibonacciApproach.make_project() } yield () } @@ -80,8 +100,8 @@ class FibonacciRecursiveVariableMainScala { } } -object FibonacciRecursiveVariableScalaDirectToDiskMain extends IOApp { - val targetDirectory = Paths.get("target", "fib", "scala") +object FibonacciRecursiveVariableMainScalaDirectToDiskMain extends IOApp { + private val targetDirectory = Paths.get("target", "fib", "scala") def run(args: List[String]): IO[ExitCode] = { diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainScala.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainScala.scala index 731f665e..944e18e9 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainScala.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainScala.scala @@ -1,9 +1,6 @@ package org.combinators.fibonacci /** - * sbt "helloWorld/runMain org.combinators.fibonacci.FibonacciIndependentScalaDirectToDiskMain" - * - * will generate the directory target/fib in which you can find the following implementation: package fibonacci def fib(n: Int): Int = { @@ -20,9 +17,12 @@ package org.combinators.fibonacci import cats.effect.{ExitCode, IO, IOApp} import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} -import org.combinators.ep.language.scala.codegen.CodeGenerator +import org.combinators.cogen.FileWithPathPersistable.* +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import org.combinators.ep.language.scala.ast.ffi.* +import org.combinators.ep.language.scala.ast.{FinalBaseAST, FinalNameProviderAST} +import org.combinators.ep.language.scala.codegen.{CodeGenerator, FullAST} +import org.combinators.fibonacci.FibonacciIndependentProvider import java.nio.file.{Path, Paths} @@ -30,23 +30,38 @@ import java.nio.file.{Path, Paths} * Takes paradigm-independent specification for Fibonacci and generates Scala code */ class FibonacciMainScala { - val generator = CodeGenerator("fibonacci") + val ast: FullAST = new FinalBaseAST + with FinalNameProviderAST + with FinalArithmeticAST + with FinalAssertionsAST + with FinalBooleanAST + with FinalEqualsAST + with FinalListsAST + with FinalOperatorExpressionsAST + with FinalRealArithmeticOpsAST + with FinalStringAST { + val reificationExtensions = List.empty + } + + val emptyset: Set[Seq[FibonacciMainScala.this.ast.any.Name]] = Set.empty + val generator: CodeGenerator[ast.type] = CodeGenerator("fibonacci", ast, emptyset) // functional - val fibonacciApproach = FibonacciIndependentProvider.functional[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl, generator.ints, generator.assertionsInMethod, generator.equality) + val fibonacciApproach = FibonacciIndependentProvider.functional[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl.functionalControlInMethods, generator.ints.arithmeticInMethods, generator.assertions.assertionsInMethods, generator.equality.equalsInMethods) - val persistable = FileWithPathPersistable[FileWithPath] + val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { val files = () => generator.paradigm.runGenerator { for { - _ <- generator.ints.enable() - _ <- generator.booleans.enable() - _ <- generator.strings.enable() - _ <- generator.equality.enable() - _ <- generator.assertionsInMethod.enable() + _ <- generator.ints.arithmeticInMethods.enable() + _ <- generator.booleans.booleansInMethodsInMethods.enable() + _ <- generator.strings.stringsInMethods.enable() + _ <- generator.equality.equalsInMethods.enable() + _ <- generator.assertions.assertionsInMethods.enable() + _ <- fibonacciApproach.make_project() } yield () } @@ -73,8 +88,8 @@ class FibonacciMainScala { } } -object FibonacciIndependentScalaDirectToDiskMain extends IOApp { - val targetDirectory = Paths.get("target", "fib", "scala") +object FibonacciMainScalaDirectToDiskMain extends IOApp { + private val targetDirectory = Paths.get("target", "fib", "scala") def run(args: List[String]): IO[ExitCode] = { diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainWithLucasScala.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainWithLucasScala.scala index e44c31e6..bae28ab4 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainWithLucasScala.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciMainWithLucasScala.scala @@ -54,9 +54,12 @@ package org.combinators.fibonacci import cats.effect.{ExitCode, IO, IOApp} import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} -import org.combinators.ep.language.scala.codegen.CodeGenerator +import org.combinators.cogen.FileWithPathPersistable.* +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import org.combinators.ep.language.scala.ast.ffi.* +import org.combinators.ep.language.scala.ast.{FinalBaseAST, FinalNameProviderAST} +import org.combinators.ep.language.scala.codegen.{CodeGenerator, FullAST} +import org.combinators.fibonacci.FibonacciWithLucasProvider import java.nio.file.{Path, Paths} @@ -64,21 +67,39 @@ import java.nio.file.{Path, Paths} * Takes functional specification of Fibonacci with Lucas and generates Scala code. */ class FibonacciMainWithLucasScala { - val generator = CodeGenerator("fibonacci") - val fibonacciApproach = FibonacciWithLucasProvider[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl, generator.ints, generator.assertionsInMethod, generator.equality) + val ast: FullAST = new FinalBaseAST + with FinalNameProviderAST + with FinalArithmeticAST + with FinalAssertionsAST + with FinalBooleanAST + with FinalEqualsAST + with FinalListsAST + with FinalOperatorExpressionsAST + with FinalRealArithmeticOpsAST + with FinalStringAST { + val reificationExtensions = List.empty + } + + val emptyset: Set[Seq[FibonacciMainWithLucasScala.this.ast.any.Name]] = Set.empty + val generator: CodeGenerator[ast.type] = CodeGenerator("fibonacci", ast, emptyset) + + val fibonacciApproach = FibonacciWithLucasProvider[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl.functionalControlInMethods, generator.ints.arithmeticInMethods, generator.assertions.assertionsInMethods, generator.equality.equalsInMethods) - val persistable = FileWithPathPersistable[FileWithPath] + //[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl, generator.ints, generator.assertionsInMethod, generator.equality) + + val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { val files = () => generator.paradigm.runGenerator { for { - _ <- generator.ints.enable() - _ <- generator.booleans.enable() - _ <- generator.strings.enable() - _ <- generator.equality.enable() - _ <- generator.assertionsInMethod.enable() + _ <- generator.ints.arithmeticInMethods.enable() + _ <- generator.booleans.booleansInMethodsInMethods.enable() + _ <- generator.strings.stringsInMethods.enable() + _ <- generator.equality.equalsInMethods.enable() + _ <- generator.assertions.assertionsInMethods.enable() + _ <- fibonacciApproach.make_project() } yield () } @@ -105,8 +126,8 @@ class FibonacciMainWithLucasScala { } } -object FibonacciWithLucasScalaDirectToDiskMain extends IOApp { - val targetDirectory:Path = Paths.get("target", "fib", "scala") +object FibonacciMainWithLucasScalaDirectToDiskMain extends IOApp { + private val targetDirectory:Path = Paths.get("target", "fib", "scala") // generated! def fib(n: Int): Int = { diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciRecursiveVariable.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciRecursiveVariable.scala index c8a30822..6647b391 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciRecursiveVariable.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciRecursiveVariable.scala @@ -1,10 +1,12 @@ package org.combinators.fibonacci -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Assertions, Equality} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.{AbstractSyntax, Command, NameProvider} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AnyParadigm, Functional} +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Assertions, Equality} +import org.combinators.cogen.Command +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{AbstractSyntax, NameProvider} trait FibonacciRecursiveVariable { val paradigm: AnyParadigm @@ -73,6 +75,7 @@ trait FibonacciRecursiveVariable { def make_unit(): Generator[paradigm.CompilationUnitContext, Unit] = { + for { _ <- functionalParadigm.compilationUnitCapabilities.addMethod(fibName, make_fibonacci()) } yield () @@ -81,6 +84,7 @@ trait FibonacciRecursiveVariable { def make_fibonacci_test(): Generator[paradigm.MethodBodyContext, Seq[paradigm.syntax.Expression]] = { import ffiEquality.equalityCapabilities._ import paradigm.methodBodyCapabilities._ + for { intType <- toTargetLanguageType(TypeRep.Int) func <- functionalParadigm.methodBodyCapabilities.findMethod(Seq(fibName)) diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciScala.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciScala.scala index 2a8e125e..452d4793 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciScala.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciScala.scala @@ -33,23 +33,38 @@ import java.nio.file.{Path, Paths} * Takes functional specification of Fibonacci with Lucas and generates Scala code. */ class FibonacciScala { - val generator = CodeGenerator("fibonacci") + val ast: FullAST = new FinalBaseAST + with FinalNameProviderAST + with FinalArithmeticAST + with FinalAssertionsAST + with FinalBooleanAST + with FinalEqualsAST + with FinalListsAST + with FinalOperatorExpressionsAST + with FinalRealArithmeticOpsAST + with FinalStringAST { + val reificationExtensions = List.empty + } + + val emptyset:Set[Seq[FibonacciScala.this.ast.any.Name]] = Set.empty + val generator: CodeGenerator[ast.type] = CodeGenerator("fibonacci", ast, emptyset) // TODO: Need to add generator.functional - val fibonacciApproach = FibonacciProvider[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl, generator.ints, generator.assertionsInMethod, generator.equality) + val fibonacciApproach = FibonacciProvider[generator.syntax.type, generator.paradigm.type](generator.paradigm)(generator.nameProvider, generator.functional, generator.functionalControl.functionalControlInMethods, generator.ints.arithmeticInMethods, generator.assertions.assertionsInMethods, generator.equality.equalsInMethods) - val persistable = FileWithPathPersistable[FileWithPath] + val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { //FIX: val files = () => generator.paradigm.runGenerator { for { - _ <- generator.ints.enable() - _ <- generator.booleans.enable() - _ <- generator.strings.enable() - _ <- generator.equality.enable() - _ <- generator.assertionsInMethod.enable() + _ <- generator.ints.arithmeticInMethods.enable() + _ <- generator.booleans.booleansInMethodsInMethods.enable() + _ <- generator.strings.stringsInMethods.enable() + _ <- generator.equality.equalsInMethods.enable() + _ <- generator.assertions.assertionsInMethods.enable() + _ <- fibonacciApproach.make_project() } yield () } @@ -77,7 +92,7 @@ class FibonacciScala { } object FibonacciScalaDirectToDiskMain extends IOApp { - val targetDirectory = Paths.get("target", "fib", "scala") + private val targetDirectory = Paths.get("target", "fib", "scala") def run(args: List[String]): IO[ExitCode] = { diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucas.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucas.scala index 452d3f67..a4e88d41 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucas.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucas.scala @@ -1,11 +1,12 @@ package org.combinators.fibonacci -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.ffi.{Arithmetic, Assertions, Equality} -import org.combinators.ep.generator.paradigm.{AnyParadigm, Functional, control} -import org.combinators.ep.generator.{AbstractSyntax, Command, NameProvider} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.control +import org.combinators.cogen.paradigm.{AnyParadigm, Functional} +import org.combinators.cogen.paradigm.ffi.{Arithmetic, Assertions, Equality} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{AbstractSyntax, Command, NameProvider} /** * Take advantage of observation that: * @@ -169,8 +170,8 @@ object FibonacciWithLucasProvider { def apply[S <: AbstractSyntax, P <: AnyParadigm.WithSyntax[S]] (base: P) (nameProvider: NameProvider[base.syntax.Name], - func: Functional.WithBase[base.type], - c1: control.Functional.WithBase[base.MethodBodyContext, base.type], + func: Functional.WithBase[base.type], + c1 : control.Functional.WithBase[base.MethodBodyContext, base.type], c2: Arithmetic.WithBase[base.MethodBodyContext, base.type, Int], c3: Assertions.WithBase[base.MethodBodyContext, base.type], c4: Equality.WithBase[base.MethodBodyContext, base.type] diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucasMainJava.scala b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucasMainJava.scala index c4f0fc84..95971158 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucasMainJava.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/FibonacciWithLucasMainJava.scala @@ -43,8 +43,8 @@ package org.combinators.fibonacci import cats.effect.{ExitCode, IO, IOApp} import com.github.javaparser.ast.PackageDeclaration import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import FileWithPathPersistable._ import org.combinators.ep.language.java.paradigm.ObjectOriented import org.combinators.ep.language.java.{CodeGenerator, JavaNameProvider, PartiallyBoxed, Syntax} @@ -58,7 +58,7 @@ class FibonacciWithLucasMainJava { val fibonacciApproach = FibonacciIndependentWithLucasProvider.imperative[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.imperativeInMethod, generator.intsInMethod, generator.assertionsInMethod, generator.equalityInMethod) - val persistable = FileWithPathPersistable[FileWithPath] + val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { diff --git a/helloworld/src/main/scala/org/combinators/fibonacci/GenericRecursionJava.scala b/helloworld/src/main/scala/org/combinators/fibonacci/GenericRecursionJava.scala index 57be67bd..096dbdf9 100644 --- a/helloworld/src/main/scala/org/combinators/fibonacci/GenericRecursionJava.scala +++ b/helloworld/src/main/scala/org/combinators/fibonacci/GenericRecursionJava.scala @@ -10,8 +10,8 @@ package org.combinators.fibonacci import cats.effect.{ExitCode, IO, IOApp} import com.github.javaparser.ast.PackageDeclaration import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import org.combinators.cogen.FileWithPathPersistable._ import org.combinators.ep.language.java.paradigm.ObjectOriented import org.combinators.ep.language.java.{CodeGenerator, JavaNameProvider, PartiallyBoxed, Syntax} diff --git a/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldMainJava.scala b/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldMainJava.scala index 01fa475d..8a49f7be 100644 --- a/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldMainJava.scala +++ b/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldMainJava.scala @@ -9,8 +9,8 @@ package org.combinators.helloworld import cats.effect.{ExitCode, IO, IOApp} import com.github.javaparser.ast.PackageDeclaration import org.apache.commons.io.FileUtils -import org.combinators.ep.generator.FileWithPathPersistable._ -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable} +import org.combinators.cogen.{FileWithPath, FileWithPathPersistable} +import FileWithPathPersistable._ import org.combinators.ep.language.java.paradigm.ObjectOriented import org.combinators.ep.language.java.{CodeGenerator, JavaNameProvider, PartiallyBoxed, Syntax} @@ -24,7 +24,7 @@ class HelloWorldMainJava { val helloWorldApproach = HelloWorldObjectOrientedProvider[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.imperativeInMethod, generator.ooParadigm, generator.consoleInMethod, generator.arraysInMethod, generator.assertionsInMethod, generator.equalityInMethod) - val persistable = FileWithPathPersistable[FileWithPath] + val persistable: Aux[FileWithPath] = FileWithPathPersistable[FileWithPath] def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { diff --git a/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldObjectOrientedProvider.scala b/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldObjectOrientedProvider.scala index 5ac26ac6..2f358b06 100644 --- a/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldObjectOrientedProvider.scala +++ b/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldObjectOrientedProvider.scala @@ -1,11 +1,11 @@ package org.combinators.helloworld -import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.control.Imperative -import org.combinators.ep.generator.paradigm.ffi.{Arrays, Assertions, Console, Equality} -import org.combinators.ep.generator.paradigm.{AnyParadigm, FindClass, ObjectOriented} -import org.combinators.ep.generator.{AbstractSyntax, Command, NameProvider, Understands} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AnyParadigm, FindClass, ObjectOriented} +import org.combinators.cogen.paradigm.control.Imperative +import org.combinators.cogen.paradigm.ffi.{Arrays, Assertions, Console, Equality} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{AbstractSyntax, Command, NameProvider, Understands} /** Any OO approach will need to properly register type mappings and provide a default mechanism for finding a class * in a variety of contexts. This trait provides that capability @@ -31,46 +31,6 @@ trait HelloWorldObjectOrientedProvider extends HelloWorldProvider { "get" + attr.capitalize } - /** - * Default registration for findClass, which works with each registerTypeMapping for the different approaches. - * - * Sometimes the mapping is fixed for an EP approach, but sometimes it matters when a particular class is requested - * in the evolution of the system over time. - */ - def domainTypeLookup[Ctxt](dtpe: DataType)(implicit canFindClass: Understands[Ctxt, FindClass[Name, Type]]): Generator[Ctxt, Type] = { - FindClass(Seq(names.mangle(names.conceptNameOf(dtpe)))).interpret(canFindClass) - } - - /** Provides meaningful default solution to find the base data type in many object-oriented approaches. - * - * This enables target-language classes to be retrieved from within the code generator in the Method, Class or Constructor contexts. - */ - def registerTypeMapping(tpe:DataType): Generator[ProjectContext, Unit] = { - import paradigm.projectCapabilities.addTypeLookupForMethods - import ooParadigm.methodBodyCapabilities.canFindClassInMethod // must be present, regardless of IntelliJ - import ooParadigm.projectCapabilities.addTypeLookupForClasses - import ooParadigm.projectCapabilities.addTypeLookupForConstructors - import ooParadigm.classCapabilities.canFindClassInClass // must be present, regardless of IntelliJ - import ooParadigm.constructorCapabilities.canFindClassInConstructor // must be present, regardless of IntelliJ - val dtpe = TypeRep.DataType(tpe) - for { - _ <- addTypeLookupForMethods(dtpe, domainTypeLookup(tpe)) - _ <- addTypeLookupForClasses(dtpe, domainTypeLookup(tpe)) - _ <- addTypeLookupForConstructors(dtpe, domainTypeLookup(tpe)) - } yield () - } - - def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] = { - import paradigm.methodBodyCapabilities._ - import ooParadigm.methodBodyCapabilities._ - for { - rt <- findClass(names.mangle(names.conceptNameOf(tpeCase))) - _ <- resolveAndAddImport(rt) - - res <- instantiateObject(rt, args) - } yield res - } - def makeSignature() : Generator[MethodBodyContext, Unit] = { import paradigm.methodBodyCapabilities._ diff --git a/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldProvider.scala b/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldProvider.scala index 87ae9578..4b1cac87 100644 --- a/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldProvider.scala +++ b/helloworld/src/main/scala/org/combinators/helloworld/HelloWorldProvider.scala @@ -1,11 +1,9 @@ package org.combinators.helloworld -import org.combinators.ep.domain.abstractions._ -import org.combinators.ep.domain.instances.{DataTypeInstance, InstanceRep} -import org.combinators.ep.generator.Command._ -import org.combinators.ep.generator.{NameProvider, Understands} -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax._ -import org.combinators.ep.generator.paradigm.{AddImport, AnyParadigm, ObjectOriented, ResolveImport} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.paradigm.{AddImport, AnyParadigm, ObjectOriented, ResolveImport} +import org.combinators.cogen.Command._ +import org.combinators.cogen.{NameProvider, Understands} /** Attempt to provide a hello world generator. */ trait HelloWorldProvider { @@ -15,16 +13,6 @@ trait HelloWorldProvider { import paradigm._ import syntax._ - /** Returns code to instantiate the given data type case, filling in `args` for its parameters. */ - def instantiate(baseTpe: DataType, tpeCase: DataTypeCase, args: Expression*): Generator[MethodBodyContext, Expression] - - /** Returns code to instantiate the given Scala model of a domain specific type. */ - def instantiate(baseType: DataType, inst: DataTypeInstance): Generator[MethodBodyContext, Expression] = { - for { - attributeInstances <- forEach (inst.attributeInstances) { ati => reify(ati) } - result <- instantiate(baseType, inst.tpeCase, attributeInstances: _*) - } yield result - } /** Available in any Context that can ResolveImport and AddImport. */ def resolveAndAddImport[Context, Elem](elem: Elem) @@ -38,7 +26,6 @@ trait HelloWorldProvider { /** Converts a Scala model of an instance of any representable type into code. */ def reify(inst: InstanceRep): Generator[MethodBodyContext, Expression] = { (inst.tpe, inst.inst) match { - case (TypeRep.DataType(baseTpe), domInst: DataTypeInstance) => instantiate(baseTpe, domInst) case (tpe, inst) => import paradigm.methodBodyCapabilities._ for { diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AbstractSyntax.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AbstractSyntax.scala index 0453c159..2c2ae517 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AbstractSyntax.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AbstractSyntax.scala @@ -1,13 +1,20 @@ -package org.combinators.ep.language.inbetween.any /*DI:LI:AI*/ - -import org.combinators.ep.generator.{ AbstractSyntax => AS } - -class AbstractSyntax[FT <: FinalTypes] extends AS { - type CompilationUnit = org.combinators.ep.language.inbetween.any.CompilationUnit[FT] - type Import = org.combinators.ep.language.inbetween.any.Import[FT] - type Expression = org.combinators.ep.language.inbetween.any.Expression[FT] - type Type = org.combinators.ep.language.inbetween.any.Type[FT] - type Statement = org.combinators.ep.language.inbetween.any.Statement[FT] - type UnitTest = Unit //TODO: org.combinators.ep.language.inbetween.any.UnitTest[FT] - type Name = org.combinators.ep.language.inbetween.any.Name[FT] +package org.combinators.ep.language.inbetween.any + +/*DI:LI:AI*/ + +import org.combinators.cogen.AbstractSyntax as AS + +trait AbstractSyntax[A](val ast: AnyAST & A) extends AS { + type CompilationUnit = ast.any.CompilationUnit + type Import = ast.any.Import + type Expression = ast.any.Expression + type Type = ast.any.Type + type Statement = ast.any.Statement + type UnitTest = Unit //TODO: ast.any.UnitTest + type Name = ast.any.Name +} + +object AbstractSyntax { + type AbstractSyntax[AST <: AnyAST] = org.combinators.ep.language.inbetween.any.AbstractSyntax[AST] { } + def apply[AST <: AnyAST](ast: AST): AbstractSyntax[ast.type] = new AbstractSyntax[ast.type](ast) {} } diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyAST.scala new file mode 100644 index 00000000..ce0372b5 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyAST.scala @@ -0,0 +1,193 @@ +package org.combinators.ep.language.inbetween.any + +import org.combinators.cogen.{FileWithPath, TypeRep} +import org.combinators.cogen.Command.Generator + +trait AnyAST { + object any { + trait FinalTypes { + type Method <: any.Method + type Import <: any.Import + type Statement <: any.Statement + type Type <: any.Type + type Name <: any.Name + type Expression <: any.Expression + type ApplyExpression <: any.ApplyExpression + type ArgumentExpression <: any.ArgumentExpression + type TestSuite <: any.TestSuite + type CompilationUnit <: any.CompilationUnit + type Project <: any.Project + } + + trait Import { + def getSelfImport: finalTypes.Import + } + + trait Statement { + def getSelfStatement: finalTypes.Statement + } + + trait Type { + def getSelfType: finalTypes.Type + } + + trait Method { + def getSelfMethod: finalTypes.Method + + def name: Name + def imports: Set[Import] = Set.empty + def statements: Seq[Statement] = Seq.empty + def returnType: Option[Type] = Option.empty + def parameters: Seq[(Name, Type)] = Seq.empty + def typeLookupMap: TypeRep => Generator[Method, Type] = Map.empty + + def addTypeLookups(lookups: TypeRep => Option[Generator[Method, Type]]): Method = { + copy(typeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.typeLookupMap(tpeRep))) + } + def getArguments: Seq[(Name, Type, Expression)] = { + parameters.map(param => (param._1, param._2, factory.argumentExpression(param._1))) + } + def addTestExpressions(exprs: Seq[Expression]): Method + + def toTargetLanguageType(tpe: TypeRep): Generator[Method, Type] = typeLookupMap(tpe) + + def reify[T](tpe: TypeRep.OfHostType[T], value: T): Expression + def resolveImport(tpe: Type): Seq[Import] + def getFreshName(basedOn: Name): Name + + def copy( + name: Name = this.name, + imports: Set[Import] = this.imports, + statements: Seq[Statement] = this.statements, + returnType: Option[Type] = this.returnType, + parameters: Seq[(Name, Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[Method, Type] = this.typeLookupMap, + ): Method = factory.method(name, imports, statements, returnType, parameters, typeLookupMap) + } + + trait Name { + def getSelfName: finalTypes.Name + } + + trait Return extends Statement { + def expression: Expression + + def copy(expression: Expression): Return = factory.returnExpression(expression) + } + + trait Expression { + def getSelfExpression: finalTypes.Expression + + def apply(other: Expression): Expression = factory.applyExpression(this, arguments = Seq(other)) + } + + trait ApplyExpression extends Expression { + import factory.* + def getSelfApplyExpression: finalTypes.ApplyExpression + + def function: Expression + def arguments: Seq[Expression] + + def copy( + function: Expression = this.function, + arguments: Seq[Expression] = this.arguments + ): ApplyExpression = factory.applyExpression(function, arguments) + } + + trait ArgumentExpression extends Expression { + def getSelfArgumentExpression: finalTypes.ArgumentExpression + + def parameterName: any.Name + + def copy( + parameterName: any.Name = this.parameterName + ): ArgumentExpression = factory.argumentExpression(parameterName) + } + + trait TestSuite { + def getSelfTestSuite: finalTypes.TestSuite + + def name: Name + + def tests: Seq[Method] + + def methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + + def initializeInCompilationUnit(compilationUnit: any.CompilationUnit): TestSuite + + def copy( + name: Name = this.name, + tests: Seq[Method] = this.tests, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap + ): TestSuite = factory.testSuite(name, tests, methodTypeLookupMap) + } + + trait CompilationUnit { + def getSelfCompilationUnit: finalTypes.CompilationUnit + + def name: Seq[Name] = Seq.empty + def imports: Seq[Import] = Seq.empty + + def tests: Seq[TestSuite] = Seq.empty + + def getFreshName(basedOn: Name): Name + + def initializeInProject(project: Project): CompilationUnit + + def copy( + name: Seq[Name] = this.name, + imports: Seq[Import] = this.imports, + tests: Seq[TestSuite] = this.tests, + ): CompilationUnit = factory.compilationUnit(name, imports, tests) + } + + trait Project { + def getSelfProject: finalTypes.Project + + def compilationUnits: Set[CompilationUnit] = Set.empty + + def customFiles: Seq[FileWithPath] = Seq.empty + + def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[Method, Type]]): Project + + def copy( + compilationUnits: Set[CompilationUnit] = this.compilationUnits, + customFiles: Seq[FileWithPath] = this.customFiles + ): Project = factory.project(compilationUnits, customFiles) + } + + trait Factory { + def project(compilationUnits: Set[CompilationUnit] = Set.empty, customFiles: Seq[FileWithPath] = Seq.empty): Project + + def compilationUnit(name: Seq[Name], imports: Seq[Import], tests: Seq[TestSuite]): CompilationUnit + + def testSuite(name: Name, tests: Seq[Method], methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty): TestSuite + def method( + name: Name, + imports: Set[Import] = Set.empty, + statements: Seq[Statement] = Seq.empty, + returnType: Option[Type] = Option.empty, + parameters: Seq[(Name, Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[Method, Type] = Map.empty, + ): Method + def returnExpression(expression: Expression): Return + def applyExpression(function: Expression, arguments: Seq[Expression]): ApplyExpression + def argumentExpression(parameterName: Name): ArgumentExpression + + implicit def convert(other: Import): finalTypes.Import = other.getSelfImport + implicit def convert(other: Statement): finalTypes.Statement = other.getSelfStatement + implicit def convert(other: Type): finalTypes.Type = other.getSelfType + implicit def convert(other: Method): finalTypes.Method = other.getSelfMethod + implicit def convert(other: Name): finalTypes.Name = other.getSelfName + implicit def convert(other: Expression): finalTypes.Expression = other.getSelfExpression + implicit def convert(other: ApplyExpression): finalTypes.ApplyExpression = other.getSelfApplyExpression + implicit def convert(other: ArgumentExpression): finalTypes.ArgumentExpression = other.getSelfArgumentExpression + implicit def convert(other: TestSuite): finalTypes.TestSuite = other.getSelfTestSuite + implicit def convert(other: CompilationUnit): finalTypes.CompilationUnit = other.getSelfCompilationUnit + implicit def convert(other: Project): finalTypes.Project = other.getSelfProject + } + } + + val finalTypes: any.FinalTypes + val factory: any.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyParadigm.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyParadigm.scala index dc2fe7d0..a060ff6e 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyParadigm.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyParadigm.scala @@ -1,21 +1,20 @@ -package org.combinators.ep.language.inbetween.any /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.any -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, FileWithPath, Understands} -import org.combinators.ep.generator.paradigm.{AddBlockDefinitions, AddCompilationUnit, AddImport, AddMethod, AddTestCase, AddTestSuite, AddTypeLookup, Apply, Debug, FreshName, GetArguments, OutputToConsole, Reify, ResolveImport, SetParameters, SetReturnType, ToTargetLanguageType, AnyParadigm => AP} +/*DI:LI:AI*/ -trait AnyParadigm extends AP { - type FT <: FinalTypes - type FactoryType <: Factory[FT] - val factory: FactoryType - val _runGenerator: Generator[Project[FT], Unit] => Seq[FileWithPath] - val syntax: AbstractSyntax[FT] - type ProjectContext = Project[FT] - type CompilationUnitContext = CompilationUnit[FT] - type TestContext = TestSuite[FT] - type MethodBodyContext = Method[FT] +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AddBlockDefinitions, AddCompilationUnit, AddCustomFile, AddImport, AddMethod, AddTestCase, AddTestSuite, AddTypeLookup, Apply, Debug, FreshName, GetArguments, OutputToConsole, Reify, ResolveImport, SetParameters, SetReturnType, ToTargetLanguageType, AnyParadigm as AP} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, FileWithPath, Understands} + +trait AnyParadigm[A, S](val ast: AnyAST & A, val syntax: AbstractSyntax.AbstractSyntax[ast.type] & S) extends AP { + import ast.factory + import ast.any.* + val _runGenerator: Generator[ast.any.Project, Unit] => Seq[FileWithPath] + type ProjectContext = Project + type CompilationUnitContext = CompilationUnit + type TestContext = TestSuite + type MethodBodyContext = Method val projectCapabilities: ProjectCapabilities = new ProjectCapabilities { implicit val canDebugInProject: Understands[ProjectContext, Debug] = new Understands[ProjectContext, Debug] { def perform(context: ProjectContext, command: Debug): (ProjectContext, Unit) = { @@ -23,40 +22,45 @@ trait AnyParadigm extends AP { (context, ()) } } - implicit val canAddCompilationUnitInProject: Understands[ProjectContext, AddCompilationUnit[Name[FT], CompilationUnitContext]] = new Understands[ProjectContext, AddCompilationUnit[Name[FT], CompilationUnitContext]] { - def perform(context: ProjectContext, command: AddCompilationUnit[Name[FT], CompilationUnitContext]): (ProjectContext, Unit) = { + implicit val canAddCompilationUnitInProject: Understands[ProjectContext, AddCompilationUnit[Name, CompilationUnitContext]] = new Understands[ProjectContext, AddCompilationUnit[Name, CompilationUnitContext]] { + def perform(context: ProjectContext, command: AddCompilationUnit[Name, CompilationUnitContext]): (ProjectContext, Unit) = { val emptyUnit = factory.compilationUnit(command.name, Seq.empty, Seq.empty).initializeInProject(context) val (generatedUnit, ()) = Command.runGenerator(command.unit, emptyUnit) (context.copy(compilationUnits = context.compilationUnits + generatedUnit), ()) } } - implicit val canAddTypeLookupForMethodsInProject: Understands[ProjectContext, AddTypeLookup[Method[FT], Type[FT]]] = new Understands[ProjectContext, AddTypeLookup[Method[FT], Type[FT]]] { - def perform(context: Project[FT], command: AddTypeLookup[Method[FT], Type[FT]]): (Project[FT], Unit) = { + implicit val canAddTypeLookupForMethodsInProject: Understands[ProjectContext, AddTypeLookup[Method, Type]] = new Understands[ProjectContext, AddTypeLookup[Method, Type]] { + def perform(context: Project, command: AddTypeLookup[Method, Type]): (Project, Unit) = { (context.addTypeLookupsForMethods((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } + implicit val canAddCustomFile: Understands[ProjectContext, AddCustomFile] = new Understands[ProjectContext, AddCustomFile] { + def perform(context: ast.any.Project, command: AddCustomFile): (ast.any.Project, Unit) = { + (context.copy(customFiles = context.customFiles :+ command.file), ()) + } + } } val compilationUnitCapabilities: CompilationUnitCapabilities = new CompilationUnitCapabilities { - implicit val canDebugInCompilationUnit: Understands[CompilationUnit[FT], Debug] = new Understands[CompilationUnitContext, Debug] { + implicit val canDebugInCompilationUnit: Understands[CompilationUnit, Debug] = new Understands[CompilationUnitContext, Debug] { def perform(context: CompilationUnitContext, command: Debug): (CompilationUnitContext, Unit) = { println(command.tag) (context, ()) } } - implicit val canAddImportInCompilationUnit: Understands[CompilationUnit[FT], AddImport[Import[FT]]] = new Understands[CompilationUnit[FT], AddImport[Import[FT]]] { - def perform(context: CompilationUnit[FT], command: AddImport[Import[FT]]): (CompilationUnit[FT], Unit) = { + implicit val canAddImportInCompilationUnit: Understands[CompilationUnit, AddImport[Import]] = new Understands[CompilationUnit, AddImport[Import]] { + def perform(context: CompilationUnit, command: AddImport[Import]): (CompilationUnit, Unit) = { (context.copy(imports = context.imports :+ command.imp), ()) } } - implicit val canAddTestSuiteInCompilationUnit: Understands[CompilationUnit[FT], AddTestSuite[Name[FT], TestContext]] = new Understands[CompilationUnit[FT], AddTestSuite[Name[FT], TestContext]] { - def perform(context: CompilationUnit[FT], command: AddTestSuite[Name[FT], TestContext]): (CompilationUnit[FT], Unit) = { + implicit val canAddTestSuiteInCompilationUnit: Understands[CompilationUnit, AddTestSuite[Name, TestContext]] = new Understands[CompilationUnit, AddTestSuite[Name, TestContext]] { + def perform(context: CompilationUnit, command: AddTestSuite[Name, TestContext]): (CompilationUnit, Unit) = { val emptyTestSuite = factory.testSuite(command.name, Seq.empty).initializeInCompilationUnit(context) val (result, ()) = Command.runGenerator(command.suite, emptyTestSuite) (context.copy(tests = context.tests :+ result), ()) } } - implicit val canGetFreshNameInCompilationUnit: Understands[CompilationUnit[FT], FreshName[Name[FT]]] = new Understands[CompilationUnit[FT], FreshName[Name[FT]]] { - def perform(context: CompilationUnit[FT], command: FreshName[Name[FT]]): (CompilationUnit[FT], Name[FT]) = { + implicit val canGetFreshNameInCompilationUnit: Understands[CompilationUnit, FreshName[Name]] = new Understands[CompilationUnit, FreshName[Name]] { + def perform(context: CompilationUnit, command: FreshName[Name]): (CompilationUnit, Name) = { (context, context.getFreshName(command.basedOn)) } } @@ -81,49 +85,49 @@ trait AnyParadigm extends AP { } implicit val canAddBlockDefinitionsInMethodBody: Understands[MethodBodyContext, AddBlockDefinitions[syntax.Statement]] = new Understands[MethodBodyContext, AddBlockDefinitions[syntax.Statement]] { - def perform(context: Method[FT], command: AddBlockDefinitions[syntax.Statement]): (Method[FT], Unit) = { - val stmts: Seq[Statement[FT]] = command.definitions + def perform(context: Method, command: AddBlockDefinitions[syntax.Statement]): (Method, Unit) = { + val stmts: Seq[Statement] = command.definitions (context.copy(statements = context.statements ++ stmts), ()) } } implicit val canSetReturnTypeInMethodBody: Understands[MethodBodyContext, SetReturnType[syntax.Type]] = new Understands[MethodBodyContext, SetReturnType[syntax.Type]] { - def perform(context: Method[FT], command: SetReturnType[Type[FT]]): (Method[FT], Unit) = { + def perform(context: Method, command: SetReturnType[Type]): (Method, Unit) = { (context.copy(returnType = Some(command.tpe)), ()) } } implicit val canSetParametersInMethodBody: Understands[MethodBodyContext, SetParameters[syntax.Name, syntax.Type]] = new Understands[MethodBodyContext, SetParameters[syntax.Name, syntax.Type]] { - def perform(context: Method[FT], command: SetParameters[Name[FT], Type[FT]]): (Method[FT], Unit) = { + def perform(context: Method, command: SetParameters[Name, Type]): (Method, Unit) = { (context.copy(parameters = command.params), ()) } } implicit val canTransformTypeInMethodBody: Understands[MethodBodyContext, ToTargetLanguageType[syntax.Type]] = new Understands[MethodBodyContext, ToTargetLanguageType[syntax.Type]] { - def perform(context: Method[FT], command: ToTargetLanguageType[Type[FT]]): (Method[FT], Type[FT]) = { + def perform(context: Method, command: ToTargetLanguageType[Type]): (Method, Type) = { Command.runGenerator(context.toTargetLanguageType(command.tpe), context) } } implicit def canReifyInMethodBody[T]: Understands[MethodBodyContext, Reify[T, syntax.Expression]] = new Understands[MethodBodyContext, Reify[T, syntax.Expression]] { - def perform(context: Method[FT], command: Reify[T, Expression[FT]]): (Method[FT], Expression[FT]) = { + def perform(context: Method, command: Reify[T, Expression]): (Method, Expression) = { (context, context.reify(command.tpe, command.value)) } } implicit val canResolveImportInMethod: Understands[MethodBodyContext, ResolveImport[syntax.Import, syntax.Type]] = new Understands[MethodBodyContext, ResolveImport[syntax.Import, syntax.Type]] { - def perform(context: Method[FT], command: ResolveImport[Import[FT], Type[FT]]): (Method[FT], Option[Import[FT]]) = { + def perform(context: Method, command: ResolveImport[Import, Type]): (Method, Option[Import]) = { (context, context.resolveImport(command.forElem).headOption) // TODO: Change code generator to Seq[Import] } } implicit val canApplyInMethodBody: Understands[MethodBodyContext, Apply[syntax.Expression, syntax.Expression, syntax.Expression]] = new Understands[MethodBodyContext, Apply[syntax.Expression, syntax.Expression, syntax.Expression]] { - def perform(context: Method[FT], command: Apply[Expression[FT], Expression[FT], Expression[FT]]): (Method[FT], Expression[FT]) = { + def perform(context: Method, command: Apply[Expression, Expression, Expression]): (Method, Expression) = { (context, factory.applyExpression(command.functional, command.arguments)) } } implicit val canGetArgumentsInMethodBody: Understands[MethodBodyContext, GetArguments[syntax.Type, syntax.Name, syntax.Expression]] = new Understands[MethodBodyContext, GetArguments[syntax.Type, syntax.Name, syntax.Expression]] { - def perform(context: Method[FT], command: GetArguments[Type[FT], Name[FT], Expression[FT]]): (Method[FT], Seq[(Name[FT], Type[FT], Expression[FT])]) = { + def perform(context: Method, command: GetArguments[Type, Name, Expression]): (Method, Seq[(Name, Type, Expression)]) = { val args = context.parameters.map(param => (param._1, param._2, factory.argumentExpression(param._1))) (context, args) } } implicit val canGetFreshNameInMethodBody: Understands[MethodBodyContext, FreshName[syntax.Name]] = new Understands[MethodBodyContext, FreshName[syntax.Name]] { - def perform(context: Method[FT], command: FreshName[Name[FT]]): (Method[FT], Name[FT]) = { + def perform(context: Method, command: FreshName[Name]): (Method, Name) = { (context, context.getFreshName(command.basedOn)) } } @@ -138,8 +142,8 @@ trait AnyParadigm extends AP { // Seem to be missing 'canAddBlockDefinitionsInTest - implicit val canAddTestCaseInTest: Understands[TestContext, AddTestCase[Method[FT], Name[FT], Expression[FT]]] = new Understands[TestContext, AddTestCase[Method[FT], Name[FT], Expression[FT]]] { - def perform(context: TestContext, command: AddTestCase[Method[FT], Name[FT], Expression[FT]]): (TestContext, Unit) = { + implicit val canAddTestCaseInTest: Understands[TestContext, AddTestCase[Method, Name, Expression]] = new Understands[TestContext, AddTestCase[Method, Name, Expression]] { + def perform(context: TestContext, command: AddTestCase[Method, Name, Expression]): (TestContext, Unit) = { val emptyMethod = factory.method( name = command.name, typeLookupMap = context.methodTypeLookupMap @@ -162,28 +166,18 @@ trait AnyParadigm extends AP { } } } - def runGenerator(generator: Generator[Project[FT], Unit]): Seq[FileWithPath] = _runGenerator(generator) + def runGenerator(generator: Generator[Project, Unit]): Seq[FileWithPath] = _runGenerator(generator) } object AnyParadigm { - type WithFT[_FT <: FinalTypes, _FactoryType <: Factory[_FT]] = AnyParadigm { - type FT = _FT - type FactoryType = _FactoryType - } + type WithAST[AST <: AnyAST] = AnyParadigm[AST, ? <: AbstractSyntax.AbstractSyntax[AST]] {} - type WithSyntax[_FT <: FinalTypes, _FactoryType <: Factory[_FT], S <: AbstractSyntax[_FT]] = AnyParadigm { - type FT = _FT - type FactoryType = _FactoryType - val syntax: S - } - def apply[_FT <: FinalTypes, _FactoryType <: Factory[_FT], S <: AbstractSyntax[_FT]] - (_factory: _FactoryType, - __runGenerator: Generator[Project[_FT], Unit] => Seq[FileWithPath], - _syntax: S - ): WithSyntax[_FT, _factory.type, _syntax.type] = new AnyParadigm { - type FT = _FT - type FactoryType = _factory.type - override val factory = _factory - override val _runGenerator: Generator[Project[FT], Unit] => Seq[FileWithPath] = __runGenerator - override val syntax: _syntax.type = _syntax + type WithSyntax[AST <: AnyAST, Syntax <: AbstractSyntax.AbstractSyntax[AST]] = AnyParadigm[AST, Syntax] {} + + def apply[AST <: AnyAST, Syntax <: AbstractSyntax.AbstractSyntax[AST]] + (_ast: AST, + __runGenerator: Generator[_ast.any.Project, Unit] => Seq[FileWithPath], + _syntax: Syntax & AbstractSyntax.AbstractSyntax[_ast.type] + ): WithSyntax[_ast.type, _syntax.type] = new AnyParadigm[_ast.type, _syntax.type](_ast, _syntax) { + override val _runGenerator: __runGenerator.type = __runGenerator } } diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/package.scala deleted file mode 100644 index e2087386..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/package.scala +++ /dev/null @@ -1,186 +0,0 @@ -package org.combinators.ep.language.inbetween /*DI:LI:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator - -package object any { - trait FinalTypes { - type Method - type Import - type Statement - type Type - type Name - type Expression - type ApplyExpression <: Expression - type ArgumentExpression <: Expression - type TestSuite - type CompilationUnit - type Project - } - - trait Import[FT <: FinalTypes] extends Factory[FT] { - def getSelfImport: finalTypes.Import - } - - trait Statement[FT <: FinalTypes] extends Factory[FT] { - def getSelfStatement: finalTypes.Statement - } - - trait Type[FT <: FinalTypes] extends Factory[FT] { - def getSelfType: finalTypes.Type - } - - trait Method[FT <: FinalTypes] extends Factory[FT] { - def getSelfMethod: finalTypes.Method - - def name: Name[FT] - def imports: Set[Import[FT]] = Set.empty - def statements: Seq[Statement[FT]] = Seq.empty - def returnType: Option[Type[FT]] = Option.empty - def parameters: Seq[(Name[FT], Type[FT])] = Seq.empty - def typeLookupMap: TypeRep => Generator[Method[FT], Type[FT]] = Map.empty - - def addTypeLookups(lookups: TypeRep => Option[Generator[Method[FT], Type[FT]]]): Method[FT] = { - copy(typeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.typeLookupMap(tpeRep))) - } - def getArguments(): Seq[(Name[FT], Type[FT], Expression[FT])] = { - parameters.map(param => (param._1, param._2, argumentExpression(param._1))) - } - def addTestExpressions(exprs: Seq[Expression[FT]]): Method[FT] - - def toTargetLanguageType(tpe: TypeRep): Generator[Method[FT], Type[FT]] = typeLookupMap(tpe) - - def reify[T](tpe: TypeRep.OfHostType[T], value: T): Expression[FT] - def resolveImport(tpe: Type[FT]): Seq[Import[FT]] - def getFreshName(basedOn: Name[FT]): Name[FT] - - def copy( - name: Name[FT] = this.name, - imports: Set[Import[FT]] = this.imports, - statements: Seq[Statement[FT]] = this.statements, - returnType: Option[Type[FT]] = this.returnType, - parameters: Seq[(Name[FT], Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[Method[FT], Type[FT]] = this.typeLookupMap, - ): Method[FT] = method(name, imports, statements, returnType, parameters) - } - - trait Name[FT <: FinalTypes] extends Factory[FT] { - def getSelfName: finalTypes.Name - } - - trait Return[FT <: FinalTypes] extends Statement[FT] with Factory[FT] { - def expression: Expression[FT] - - def copy(expression: Expression[FT]): Return[FT] = returnExpression(expression) - } - - trait Expression[FT <: FinalTypes] extends Factory[FT] { - def getSelfExpression: finalTypes.Expression - - def apply(other: Expression[FT]): Expression[FT] = applyExpression(this, arguments=Seq(other)) - } - - trait ApplyExpression[FT <: FinalTypes] extends Expression[FT] with Factory[FT] { - def getSelfApplyExpression: finalTypes.ApplyExpression - - def function: Expression[FT] - def arguments: Seq[Expression[FT]] - - def copy( - function: Expression[FT] = this.function, - arguments: Seq[Expression[FT]] = this.arguments - ): ApplyExpression[FT] = applyExpression(function, arguments) - } - - trait ArgumentExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfArgumentExpression: finalTypes.ArgumentExpression - - def parameterName: any.Name[FT] - - def copy( - parameterName: any.Name[FT] = this.parameterName - ): ArgumentExpression[FT] = argumentExpression(parameterName) - } - - trait TestSuite[FT <: FinalTypes] extends Factory[FT] { - def getSelfTestSuite: finalTypes.TestSuite - - def name: Name[FT] - - def tests: Seq[Method[FT]] - - def methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - - def initializeInCompilationUnit(compilationUnit: any.CompilationUnit[FT]): TestSuite[FT] - - def copy( - name: Name[FT] = this.name, - tests: Seq[Method[FT]] = this.tests, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap - ): TestSuite[FT] = testSuite(name, tests, methodTypeLookupMap) - } - - trait CompilationUnit[FT <: FinalTypes] extends Factory[FT] { - def getSelfCompilationUnit: finalTypes.CompilationUnit - - def name: Seq[Name[FT]] = Seq.empty - def imports: Seq[Import[FT]] = Seq.empty - - def tests: Seq[TestSuite[FT]] = Seq.empty - - def getFreshName(basedOn: Name[FT]): Name[FT] - - def initializeInProject(project: Project[FT]): CompilationUnit[FT] - - def copy( - name: Seq[Name[FT]] = this.name, - imports: Seq[Import[FT]] = this.imports, - tests: Seq[TestSuite[FT]] = this.tests, - ): CompilationUnit[FT] = compilationUnit(name, imports, tests) - } - - trait Project[FT <: FinalTypes] extends Factory[FT] { - def getSelfProject: finalTypes.Project - - def compilationUnits: Set[CompilationUnit[FT]] = Set.empty - - def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[Method[FT], Type[FT]]]): Project[FT] - - def copy( - compilationUnits: Set[CompilationUnit[FT]] = this.compilationUnits - ): Project[FT] = project(compilationUnits) - } - - trait Factory[FT <: FinalTypes] { - val finalTypes: FT - - def project(compilationUnits: Set[CompilationUnit[FT]] = Set.empty): Project[FT] - - def compilationUnit(name: Seq[Name[FT]], imports: Seq[Import[FT]], tests: Seq[TestSuite[FT]]): CompilationUnit[FT] - - def testSuite(name: Name[FT], tests: Seq[Method[FT]], methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty): TestSuite[FT] - def method( - name: Name[FT], - imports: Set[Import[FT]] = Set.empty, - statements: Seq[Statement[FT]] = Seq.empty, - returnType: Option[Type[FT]] = Option.empty, - parameters: Seq[(Name[FT], Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[Method[FT], Type[FT]] = Map.empty, - ): Method[FT] - def returnExpression(expression: Expression[FT]): Return[FT] - def applyExpression(function: Expression[FT], arguments: Seq[Expression[FT]]): ApplyExpression[FT] - def argumentExpression(parameterName: Name[FT]): ArgumentExpression[FT] - - implicit def convert(other: Import[FT]): Import[FT] - implicit def convert(other: Statement[FT]): Statement[FT] - implicit def convert(other: Type[FT]): Type[FT] - implicit def convert(other: Method[FT]): Method[FT] - implicit def convert(other: Name[FT]): Name[FT] - implicit def convert(other: Expression[FT]): Expression[FT] - implicit def convert(other: ApplyExpression[FT]): ApplyExpression[FT] - implicit def convert(other: ArgumentExpression[FT]): ArgumentExpression[FT] - implicit def convert(other: TestSuite[FT]): TestSuite[FT] - implicit def convert(other: CompilationUnit[FT]): CompilationUnit[FT] - implicit def convert(other: Project[FT]): Project[FT] - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Arithmetic.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Arithmetic.scala index f0a2e410..c5898945 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Arithmetic.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Arithmetic.scala @@ -1,100 +1,72 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.ffi -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Add, Div, LE, LT, Mod, Mult, Sub, Arithmetic => Arith} +/*DI:LI:AI*/ + +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Add, Div, LE, LT, Mod, Mult, Sub, Arithmetic as Arith} +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.Command.Generator import org.combinators.ep.language.inbetween.any import org.combinators.ep.language.inbetween.any.AnyParadigm -// cannot find 'arithmetic' -trait Arithmetic[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: ArithmeticOps.Factory[FT], T] extends Arith[any.Method[FT], T] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory - val arithmeticCapabilities: ArithmeticCapabilities = new ArithmeticCapabilities { - implicit val canLT: Understands[any.Method[FT], Apply[LT[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[LT[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[LT[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.lt(command.arguments(0), command.arguments(1))) + +trait Arithmetic[AST <: ArithmeticAST, B, T](val _base: AnyParadigm.WithAST[AST] & B) { + trait ArithmeticInMethods extends Arith[_base.ast.any.Method, T] { + override val base: _base.type = _base + + import base.ast.any + import base.ast.arithmeticOpsFactory + + val arithmeticCapabilities: ArithmeticCapabilities = new ArithmeticCapabilities { + implicit val canLT: Understands[any.Method, Apply[LT[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[LT[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[LT[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.lt(command.arguments(0), command.arguments(1))) + } } - } - implicit val canLE: Understands[any.Method[FT], Apply[LE[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[LE[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[LE[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.le(command.arguments(0), command.arguments(1))) + implicit val canLE: Understands[any.Method, Apply[LE[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[LE[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[LE[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.le(command.arguments(0), command.arguments(1))) + } } - } - implicit val canAdd: Understands[any.Method[FT], Apply[Add[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Add[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Add[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.add(command.arguments(0), command.arguments(1))) + implicit val canAdd: Understands[any.Method, Apply[Add[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Add[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Add[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.add(command.arguments(0), command.arguments(1))) + } } - } - implicit val canSub: Understands[any.Method[FT], Apply[Sub[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Sub[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Sub[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.sub(command.arguments(0), command.arguments(1))) + implicit val canSub: Understands[any.Method, Apply[Sub[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Sub[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Sub[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.sub(command.arguments(0), command.arguments(1))) + } } - } - implicit val canMult: Understands[any.Method[FT], Apply[Mult[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Mult[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Mult[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.mult(command.arguments(0), command.arguments(1))) + implicit val canMult: Understands[any.Method, Apply[Mult[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Mult[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Mult[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.mult(command.arguments(0), command.arguments(1))) + } } - } - implicit val canDiv: Understands[any.Method[FT], Apply[Div[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Div[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Div[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.div(command.arguments(0), command.arguments(1))) + implicit val canDiv: Understands[any.Method, Apply[Div[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Div[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Div[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.div(command.arguments(0), command.arguments(1))) + } } - } - implicit val canMod: Understands[any.Method[FT], Apply[Mod[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Mod[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Mod[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.mod(command.arguments(0), command.arguments(1))) + implicit val canMod: Understands[any.Method, Apply[Mod[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Mod[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Mod[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, arithmeticOpsFactory.mod(command.arguments(0), command.arguments(1))) + } } - } + } + def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] } - def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] + + val arithmeticInMethods: ArithmeticInMethods = new ArithmeticInMethods {} } object Arithmetic { - type WithBase[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: ArithmeticOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType], T] = Arithmetic[FT, FactoryType, T] { val base: B } - def apply[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: ArithmeticOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType], T](_base: B): WithBase[FT, FactoryType, _base.type, T] = new Arithmetic[FT, FactoryType, T] { - val base: _base.type = _base - } + type WithBase[T, AST <: ArithmeticAST, B <: AnyParadigm.WithAST[AST]] = Arithmetic[AST, B, T] {} + def apply[T, AST <: ArithmeticAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[T, AST, B] = new Arithmetic[AST, B, T](_base) {} } - -object ArithmeticOps { - trait AddOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait SubOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait MultOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait DivOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait ModOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait LtOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait LeOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - - trait Factory[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Factory[FT] { - def addOp(): AddOp[FT] - def subOp(): SubOp[FT] - def multOp(): MultOp[FT] - def divOp(): DivOp[FT] - def modOp(): ModOp[FT] - def ltOp(): LtOp[FT] - def leOp(): LeOp[FT] - - def add(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(addOp(), left, right) - def sub(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(subOp(), left, right) - def mult(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(multOp(), left, right) - def div(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(divOp(), left, right) - def mod(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(modOp(), left, right) - def lt(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(ltOp(), left, right) - def le(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(leOp(), left, right) - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ArithmeticAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ArithmeticAST.scala new file mode 100644 index 00000000..1264df09 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ArithmeticAST.scala @@ -0,0 +1,40 @@ +package org.combinators.ep.language.inbetween.ffi + +trait ArithmeticAST extends OperatorExpressionOpsAST { + object arithmeticOps { + trait AddOp extends operatorExpressions.Operator + trait SubOp extends operatorExpressions.Operator + trait MultOp extends operatorExpressions.Operator + trait DivOp extends operatorExpressions.Operator + trait ModOp extends operatorExpressions.Operator + trait LtOp extends operatorExpressions.Operator + trait LeOp extends operatorExpressions.Operator + + trait Factory { + def addOp(): AddOp + def subOp(): SubOp + def multOp(): MultOp + def divOp(): DivOp + def modOp(): ModOp + def ltOp(): LtOp + def leOp(): LeOp + + def add(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(addOp(), left, right) + def sub(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(subOp(), left, right) + def mult(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(multOp(), left, right) + def div(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(divOp(), left, right) + def mod(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(modOp(), left, right) + def lt(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(ltOp(), left, right) + def le(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(leOp(), left, right) + } + } + + val arithmeticOpsFactory: arithmeticOps.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Assertions.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Assertions.scala index 5274486b..95c835be 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Assertions.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Assertions.scala @@ -1,42 +1,36 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.ffi -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Assert, Assertions => Asrts} +/*DI:LI:AI*/ + +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Assert, Assertions as Asrts} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.inbetween.any import org.combinators.ep.language.inbetween.any.AnyParadigm // cannot find 'assertions' -trait Assertions[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: AssertionOps.Factory[FT]] extends Asrts[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory +trait Assertions[AST <: AssertionsAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait AssertionsInMethods extends Asrts[_base.ast.any.Method] { + val base: _base.type = _base + import base.ast.assertionOpsFactory + import base.ast.any - val assertionCapabilities: AssertionCapabilities = new AssertionCapabilities { - implicit val canAssert: Understands[any.Method[FT], Apply[Assert, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Assert, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Assert, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.assertTrue(command.arguments.head)) + val assertionCapabilities: AssertionCapabilities = new AssertionCapabilities { + implicit val canAssert: Understands[any.Method, Apply[Assert, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Assert, any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Assert, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, assertionOpsFactory.assertTrue(command.arguments.head)) + } } - } + } + def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] } - def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] + val assertionsInMethods: AssertionsInMethods = new AssertionsInMethods {} } object Assertions { - type WithBase[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: AssertionOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Assertions[FT, FactoryType] { val base: B } - def apply[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: AssertionOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Assertions[FT, FactoryType] { - val base: _base.type = _base - } -} - -object AssertionOps { - trait AssertTrueOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] + type WithBase[AST <: AssertionsAST, B <: AnyParadigm.WithAST[AST]] = Assertions[AST, B] {} - trait Factory[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Factory[FT] { - def assertTrueOp(): AssertTrueOp[FT] - - def assertTrue(exp: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(assertTrueOp(), exp) - } + def apply[AST <: AssertionsAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Assertions[AST, B](_base) {} } \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/AssertionsAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/AssertionsAST.scala new file mode 100644 index 00000000..4591fbea --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/AssertionsAST.scala @@ -0,0 +1,15 @@ +package org.combinators.ep.language.inbetween.ffi + +trait AssertionsAST extends OperatorExpressionOpsAST { + object assertionOps { + trait AssertTrueOp extends operatorExpressions.Operator + + trait Factory { + def assertTrueOp(): AssertTrueOp + + def assertTrue(exp: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(assertTrueOp(), exp) + } + } + val assertionOpsFactory: assertionOps.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Boolean.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Boolean.scala deleted file mode 100644 index 4687bf97..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Boolean.scala +++ /dev/null @@ -1,86 +0,0 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Booleans => Bools, _} -import org.combinators.ep.language.inbetween.any -import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.Command - -// cannot find 'boolean' -trait Booleans[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: BooleanOps.Factory[FT]] extends Bools[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory - val booleanCapabilities: BooleanCapabilities = - new BooleanCapabilities { - implicit val canAnd: Understands[any.Method[FT], Apply[And, any.Expression[FT], any.Expression[FT]]] = new Understands[any.Method[FT], Apply[And, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[And, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val andExp = if (command.arguments.isEmpty) { - factory.falseExp() - } else { - command.arguments.reverse.tail.foldRight(command.arguments.reverse.head) { case (s, arg) => factory.and(arg, s) } - } - (context, andExp) - } - } - implicit val canOr: Understands[any.Method[FT], Apply[Or, any.Expression[FT], any.Expression[FT]]] = new Understands[any.Method[FT], Apply[Or, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Or, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val orExp = if (command.arguments.isEmpty) { factory.trueExp() } else { - command.arguments.reverse.tail.foldRight(command.arguments.reverse.head){ case (s, arg) => factory.or(arg, s) } - } - (context, orExp) - } - } - implicit val canNot: Understands[any.Method[FT], Apply[Not, any.Expression[FT], any.Expression[FT]]] = new Understands[any.Method[FT], Apply[Not, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Not, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.not(command.arguments.head)) - } - } - implicit val canTrue: Understands[any.Method[FT], True[any.Expression[FT]]] = new Understands[any.Method[FT], True[any.Expression[FT]]] { - def perform(context: any.Method[FT], command: True[any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.trueExp()) - } - } - implicit val canFalse: Understands[any.Method[FT], False[any.Expression[FT]]] = new Understands[any.Method[FT], False[any.Expression[FT]]] { - def perform(context: any.Method[FT], command: False[any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.falseExp()) - } - } - } - - override def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] -} - -object Booleans { - type WithBase[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: BooleanOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Booleans[FT, FactoryType] { val base: B } - def apply[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: BooleanOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Booleans[FT, FactoryType] { - val base: _base.type = _base - } -} - -object BooleanOps { - trait AndOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait OrOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - - trait NotOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - - trait True[FT <: OperatorExpressionOps.FinalTypes] extends any.Expression[FT] - trait False[FT <: OperatorExpressionOps.FinalTypes] extends any.Expression[FT] - - trait Factory[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Factory[FT] { - def andOp(): AndOp[FT] - def orOp(): OrOp[FT] - def notOp(): NotOp[FT] - - def trueExp(): True[FT] - def falseExp(): False[FT] - def and(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(andOp(), left, right) - def or(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(orOp(), left, right) - def not(exp: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(notOp(), exp) - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/BooleanAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/BooleanAST.scala new file mode 100644 index 00000000..661b40e4 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/BooleanAST.scala @@ -0,0 +1,31 @@ +package org.combinators.ep.language.inbetween.ffi + +trait BooleanAST extends OperatorExpressionOpsAST { + object booleanOps { + trait AndOp extends operatorExpressions.Operator + + trait OrOp extends operatorExpressions.Operator + + trait NotOp extends operatorExpressions.Operator + + trait True extends any.Expression + + trait False extends any.Expression + + trait Factory { + def andOp(): AndOp + def orOp(): OrOp + def notOp(): NotOp + + def trueExp(): True + def falseExp(): False + def and(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(andOp(), left, right) + def or(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(orOp(), left, right) + def not(exp: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(notOp(), exp) + } + } + val booleanOpsFactory: booleanOps.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Booleans.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Booleans.scala new file mode 100644 index 00000000..74fffce2 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Booleans.scala @@ -0,0 +1,71 @@ +package org.combinators.ep.language.inbetween.ffi + +/*DI:LI:AI*/ + +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{And, False, Not, Or, True, Booleans as Bools} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.Understands +import org.combinators.cogen.paradigm.ffi.* +import org.combinators.ep.language.inbetween.any +import org.combinators.ep.language.inbetween.any.AnyParadigm +import org.combinators.cogen.Command + +// cannot find 'boolean' +trait Booleans[AST <: BooleanAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait BooleansInMethods extends Bools[_base.ast.any.Method] { + override val base: _base.type = _base + + import base.ast.any + import base.ast.booleanOpsFactory + + val booleanCapabilities: BooleanCapabilities = + new BooleanCapabilities { + implicit val canAnd: Understands[any.Method, Apply[And, any.Expression, any.Expression]] = new Understands[any.Method, Apply[And, any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[And, any.Expression, any.Expression]): (any.Method, any.Expression) = { + val andExp = if (command.arguments.isEmpty) { + booleanOpsFactory.falseExp() + } else { + command.arguments.reverse.tail.foldRight(command.arguments.reverse.head) { case (s, arg) => booleanOpsFactory.and(arg, s) } + } + (context, andExp) + } + } + implicit val canOr: Understands[any.Method, Apply[Or, any.Expression, any.Expression]] = new Understands[any.Method, Apply[Or, any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Or, any.Expression, any.Expression]): (any.Method, any.Expression) = { + val orExp = if (command.arguments.isEmpty) { + booleanOpsFactory.trueExp() + } else { + command.arguments.reverse.tail.foldRight(command.arguments.reverse.head) { case (s, arg) => booleanOpsFactory.or(arg, s) } + } + (context, orExp) + } + } + implicit val canNot: Understands[any.Method, Apply[Not, any.Expression, any.Expression]] = new Understands[any.Method, Apply[Not, any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Not, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, booleanOpsFactory.not(command.arguments.head)) + } + } + implicit val canTrue: Understands[any.Method, True[any.Expression]] = new Understands[any.Method, True[any.Expression]] { + def perform(context: any.Method, command: True[any.Expression]): (any.Method, any.Expression) = { + (context, booleanOpsFactory.trueExp()) + } + } + implicit val canFalse: Understands[any.Method, False[any.Expression]] = new Understands[any.Method, False[any.Expression]] { + def perform(context: any.Method, command: False[any.Expression]): (any.Method, any.Expression) = { + (context, booleanOpsFactory.falseExp()) + } + } + } + override def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] + } + + val booleansInMethodsInMethods: BooleansInMethods = new BooleansInMethods {} +} + +object Booleans { + type WithBase[AST <: BooleanAST, B <: AnyParadigm.WithAST[AST]] = Booleans[AST, B] {} + + def apply[AST <: BooleanAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Booleans[AST, B](_base) {} +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Equals.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Equals.scala index 397cdb2c..650552b7 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Equals.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Equals.scala @@ -1,50 +1,36 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.ffi -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.{Apply, ffi} -import org.combinators.ep.generator.paradigm.ffi.{Equality => Eqls, _} +/*DI:LI:AI*/ + +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.paradigm.ffi.{Equality as Eqls, *} +import org.combinators.cogen.paradigm.{Apply, ffi} import org.combinators.ep.language.inbetween.any import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.Command -trait Equals[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: EqualsOps.Factory[FT]] extends Eqls[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory +trait Equals[AST <: EqualsAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait BooleansInMethods extends Eqls[_base.ast.any.Method] { + override val base: _base.type = _base + + import base.ast.{any, equalsOpFactory} - val equalityCapabilities: EqualityCapabilities = new EqualityCapabilities { - implicit val canEquals: Understands[any.Method[FT], Apply[ffi.Equals[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] = new Understands[any.Method[FT], Apply[ffi.Equals[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[ffi.Equals[any.Type[FT]], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.equals(command.functional.inType, command.arguments.head, command.arguments.tail.head)) + val equalityCapabilities: EqualityCapabilities = new EqualityCapabilities { + implicit val canEquals: Understands[any.Method, Apply[ffi.Equals[any.Type], any.Expression, any.Expression]] = new Understands[any.Method, Apply[ffi.Equals[any.Type], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[ffi.Equals[any.Type], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, equalsOpFactory.equals(command.functional.inType, command.arguments.head, command.arguments.tail.head)) + } } } + def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] } - def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] + val equalsInMethods: BooleansInMethods = new BooleansInMethods {} } object Equals { - type WithBase[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: EqualsOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Equals[FT, FactoryType] { val base: B } - def apply[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: EqualsOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Equals[FT, FactoryType] { - val base: _base.type = _base - } -} + type WithBase[AST <: EqualsAST, B <: AnyParadigm.WithAST[AST]] = Equals[AST, B] {} -object EqualsOps { - trait Equals[FT <: any.FinalTypes] extends any.Expression[FT] with Factory[FT] { - def tpe: any.Type[FT] - def left: any.Expression[FT] - def right: any.Expression[FT] - - def copy( - tpe: any.Type[FT], - left: any.Expression[FT] = left, - right: any.Expression[FT] = right - ): Equals[FT] = equals(tpe, left, right) - } + def apply[AST <: EqualsAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Equals[AST, B](_base) {} +} - trait Factory[FT <: any.FinalTypes] extends any.Factory[FT] { - def equals(tpe: any.Type[FT], left: any.Expression[FT], right: any.Expression[FT]): Equals[FT] - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/EqualsAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/EqualsAST.scala new file mode 100644 index 00000000..549b8d5c --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/EqualsAST.scala @@ -0,0 +1,22 @@ +package org.combinators.ep.language.inbetween.ffi + +trait EqualsAST extends OperatorExpressionOpsAST { + object equalsOp { + trait Equals extends any.Expression { + def tpe: any.Type + def left: any.Expression + def right: any.Expression + + def copy( + tpe: any.Type, + left: any.Expression = left, + right: any.Expression = right + ): Equals = equalsOpFactory.equals(tpe, left, right) + } + + trait Factory { + def equals(tpe: any.Type, left: any.Expression, right: any.Expression): Equals + } + } + val equalsOpFactory: equalsOp.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Lists.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Lists.scala index 1070987c..d30ec494 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Lists.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Lists.scala @@ -1,91 +1,64 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.ffi + +/*DI:LI:AI*/ // cannot find 'lists' -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.Apply + +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Append, Cons, Create, Head, Tail, Lists as Lsts} +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.Command.Generator import org.combinators.ep.language.inbetween.{any, polymorphism} import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{Append, Cons, Create, Head, Tail, Lists => Lsts} -trait Lists[FT <: ListOps.FinalTypes, FactoryType <: ListOps.Factory[FT]] extends Lsts[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory - override val listCapabilities: ListCapabilities = new ListCapabilities { - override implicit val canCreate: Understands[any.Method[FT], Apply[Create[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Create[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: Apply[Create[any.Type[FT]], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.createList(command.functional.elementType, command.arguments)) +trait Lists[AST <: ListsAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait ListsInMethods extends Lsts[_base.ast.any.Method] { + val base: _base.type = _base + + import base.ast.listsOpsFactory + import base.ast.any + + override val listCapabilities: ListCapabilities = new ListCapabilities { + override implicit val canCreate: Understands[any.Method, Apply[Create[any.Type], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Create[any.Type], any.Expression, any.Expression]] { + override def perform(context: any.Method, command: Apply[Create[any.Type], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, listsOpsFactory.createList(command.functional.elementType, command.arguments)) + } } - } - override implicit val canCons: Understands[any.Method[FT], Apply[Cons, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Cons, any.Expression[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: Apply[Cons, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.consList(command.arguments(0), command.arguments(1))) + override implicit val canCons: Understands[any.Method, Apply[Cons, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Cons, any.Expression, any.Expression]] { + override def perform(context: any.Method, command: Apply[Cons, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, listsOpsFactory.consList(command.arguments(0), command.arguments(1))) + } } - } - override implicit val canHead: Understands[any.Method[FT], Apply[Head, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Head, any.Expression[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: Apply[Head, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.head(command.arguments(0))) + override implicit val canHead: Understands[any.Method, Apply[Head, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Head, any.Expression, any.Expression]] { + override def perform(context: any.Method, command: Apply[Head, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, listsOpsFactory.head(command.arguments(0))) + } } - } - override implicit val canTail: Understands[any.Method[FT], Apply[Tail, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Tail, any.Expression[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: Apply[Tail, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.tail(command.arguments(0))) + override implicit val canTail: Understands[any.Method, Apply[Tail, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Tail, any.Expression, any.Expression]] { + override def perform(context: any.Method, command: Apply[Tail, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, listsOpsFactory.tail(command.arguments(0))) + } } - } - override implicit val canAppend: Understands[any.Method[FT], Apply[Append, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Append, any.Expression[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: Apply[Append, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.appendList(command.arguments(0), command.arguments(1))) + override implicit val canAppend: Understands[any.Method, Apply[Append, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Append, any.Expression, any.Expression]] { + override def perform(context: any.Method, command: Apply[Append, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, listsOpsFactory.appendList(command.arguments(0), command.arguments(1))) + } } - } + } + override def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] } - - override def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] + + val listsInMethods: ListsInMethods = new ListsInMethods {} } object Lists { - type WithBase[FT <: ListOps.FinalTypes, FactoryType <: ListOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Lists[FT, FactoryType] { val base: B } - def apply[FT <: ListOps.FinalTypes, FactoryType <: ListOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Lists[FT, FactoryType] { - val base: _base.type = _base - } -} - -object ListOps { - - trait FinalTypes extends OperatorExpressionOps.FinalTypes with polymorphism.FinalTypes { + type WithBase[AST <: ListsAST, B <: AnyParadigm.WithAST[AST]] = Lists[AST, B] {} - } - trait CreateList[FT <: FinalTypes] extends any.Type[FT] - trait ConsListOp[FT <: FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait HeadListOp[FT <: FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait TailListOp[FT <: FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait AppendListOp[FT <: FinalTypes] extends OperatorExpressionOps.Operator[FT] - - trait Factory[FT <: FinalTypes] extends OperatorExpressionOps.Factory[FT] with polymorphism.Factory[FT] { - def createList(): CreateList[FT] - - def createList(tpe: any.Type[FT], elems: Seq[any.Expression[FT]]): any.ApplyExpression[FT] = - applyExpression(typeReferenceExpression(typeApplication(createList(), Seq(tpe))), elems) - - def consListOp(): ConsListOp[FT] - def headListOp(): HeadListOp[FT] - - def tailListOp(): TailListOp[FT] - - def appendListOp(): AppendListOp[FT] - - def consList(element: any.Expression[FT], list: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(consListOp(), element, list) - def head(list: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(headListOp(), list) - - def tail(list: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(tailListOp(), list) - def appendList(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(appendListOp(), left, right) - } + def apply[AST <: ListsAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Lists[AST, B](_base) {} } + diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ListsAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ListsAST.scala new file mode 100644 index 00000000..062c6931 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ListsAST.scala @@ -0,0 +1,42 @@ +package org.combinators.ep.language.inbetween.ffi + +import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphismAST + +trait ListsAST extends OperatorExpressionOpsAST with ParametricPolymorphismAST { + object listsOps { + trait CreateList extends any.Type + + trait ConsListOp extends operatorExpressions.Operator + + trait HeadListOp extends operatorExpressions.Operator + + trait TailListOp extends operatorExpressions.Operator + + trait AppendListOp extends operatorExpressions.Operator + + trait Factory { + def createList(): CreateList + + def createList(tpe: any.Type, elems: Seq[any.Expression]): any.ApplyExpression = + factory.applyExpression(polymorphismFactory.typeReferenceExpression(polymorphismFactory.typeApplication(createList(), Seq(tpe))), elems) + + def consListOp(): ConsListOp + def headListOp(): HeadListOp + + def tailListOp(): TailListOp + + def appendListOp(): AppendListOp + + def consList(element: any.Expression, list: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(consListOp(), element, list) + def head(list: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(headListOp(), list) + + def tail(list: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(tailListOp(), list) + def appendList(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(appendListOp(), left, right) + } + } + val listsOpsFactory: listsOps.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/OperatorExpressionOps.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/OperatorExpressionOps.scala deleted file mode 100644 index 6aae550d..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/OperatorExpressionOps.scala +++ /dev/null @@ -1,49 +0,0 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ - -import org.combinators.ep.language.inbetween.any - -object OperatorExpressionOps { - trait FinalTypes extends any.FinalTypes { - type Operator - type BinaryExpression <: Expression - type UnaryExpression <: Expression - } - - trait BinaryExpression[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfBinaryExpression: finalTypes.BinaryExpression - def operator: Operator[FT] - def left: any.Expression[FT] - def right: any.Expression[FT] - - def copy( - operator: Operator[FT] = operator, - left: any.Expression[FT] = left, - right: any.Expression[FT] = right - ): BinaryExpression[FT] = binaryExpression(operator, left, right) - } - - trait UnaryExpression[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfUnaryExpression: finalTypes.UnaryExpression - def operator: Operator[FT] - def operand: any.Expression[FT] - - def copy( - operator: Operator[FT] = operator, - operand: any.Expression[FT] = operand - ): UnaryExpression[FT] = unaryExpression(operator, operand) - } - - trait Operator[FT <: FinalTypes] extends Factory[FT] { - def getSelfOperator: finalTypes.Operator - } - - trait Factory[FT <: FinalTypes] extends any.Factory[FT] { - - def binaryExpression(operator: Operator[FT], left: any.Expression[FT], right: any.Expression[FT]): BinaryExpression[FT] - def unaryExpression(operator: Operator[FT], operand: any.Expression[FT]): UnaryExpression[FT] - - implicit def convert(operator: Operator[FT]): Operator[FT] - implicit def convert(binaryExpression: BinaryExpression[FT]): BinaryExpression[FT] - implicit def convert(unaryExpression: UnaryExpression[FT]): UnaryExpression[FT] - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/OperatorExpressionOpsAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/OperatorExpressionOpsAST.scala new file mode 100644 index 00000000..b2a75b3e --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/OperatorExpressionOpsAST.scala @@ -0,0 +1,54 @@ +package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ + +import org.combinators.ep.language.inbetween.any +import org.combinators.ep.language.inbetween.any.AnyAST + +trait OperatorExpressionOpsAST extends AnyAST { + object operatorExpressions { + trait FinalTypes { + type Operator <: operatorExpressions.Operator + type BinaryExpression <: operatorExpressions.BinaryExpression + type UnaryExpression <: operatorExpressions.UnaryExpression + } + + trait BinaryExpression extends any.Expression { + def getSelfBinaryExpression: operatorExpressionsFinalTypes.BinaryExpression + def operator: Operator + def left: any.Expression + def right: any.Expression + + def copy( + operator: Operator = operator, + left: any.Expression = left, + right: any.Expression = right + ): BinaryExpression = operatorExpressionsFactory.binaryExpression(operator, left, right) + } + + trait UnaryExpression extends any.Expression { + def getSelfUnaryExpression: operatorExpressionsFinalTypes.UnaryExpression + def operator: Operator + def operand: any.Expression + + def copy( + operator: Operator = operator, + operand: any.Expression = operand + ): UnaryExpression = operatorExpressionsFactory.unaryExpression(operator, operand) + } + + trait Operator { + def getSelfOperator: operatorExpressionsFinalTypes.Operator + } + + trait Factory { + def binaryExpression(operator: Operator, left: any.Expression, right: any.Expression): BinaryExpression + def unaryExpression(operator: Operator, operand: any.Expression): UnaryExpression + + implicit def convert(other: Operator): operatorExpressionsFinalTypes.Operator = other.getSelfOperator + implicit def convert(other: BinaryExpression): operatorExpressionsFinalTypes.BinaryExpression = other.getSelfBinaryExpression + implicit def convert(other: UnaryExpression): operatorExpressionsFinalTypes.UnaryExpression = other.getSelfUnaryExpression + } + } + + val operatorExpressionsFinalTypes: operatorExpressions.FinalTypes + val operatorExpressionsFactory: operatorExpressions.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmetic.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmetic.scala index bc1ce11f..85cad49e 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmetic.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmetic.scala @@ -1,121 +1,84 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.ffi -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Abs, Add, Cos, Div, EulersNumber, Floor, LE, LT, Log, Mod, Mult, Pi, Pow, Sin, Sqrt, Sub, RealArithmetic => RealArith} +/*DI:LI:AI*/ + +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Abs, Add, Cos, Div, EulersNumber, Floor, LE, LT, Log, Mod, Mult, Pi, Pow, Sin, Sqrt, Sub, RealArithmetic as RealArith} +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.Command.Generator import org.combinators.ep.language.inbetween.any import org.combinators.ep.language.inbetween.any.AnyParadigm -// cannot find 'realArithmetic' -trait RealArithmetic[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: RealArithmeticOps.Factory[FT], T] extends RealArith[any.Method[FT], T] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory - val realArithmeticCapabilities: RealArithmeticCapabilities = new RealArithmeticCapabilities { - implicit val canSqrt: Understands[any.Method[FT], Apply[Sqrt[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Sqrt[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Sqrt[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.sqrt(command.arguments.head)) +trait RealArithmetic[AST <: RealArithmeticAST, B, T](val _base: AnyParadigm.WithAST[AST] & B) { + trait RealArithmeticInMethods extends RealArith[_base.ast.any.Method, T] { + val base: _base.type = _base + + import base.ast.realArithmeticOpsFactory + import base.ast.any + + val realArithmeticCapabilities: RealArithmeticCapabilities = new RealArithmeticCapabilities { + implicit val canSqrt: Understands[any.Method, Apply[Sqrt[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Sqrt[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Sqrt[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.sqrt(command.arguments.head)) + } } - } - implicit val canPow: Understands[any.Method[FT], Apply[Pow[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Pow[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Pow[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.pow(command.arguments.head, command.arguments.tail.head)) + implicit val canPow: Understands[any.Method, Apply[Pow[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Pow[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Pow[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.pow(command.arguments.head, command.arguments.tail.head)) + } } - } - implicit val canLog: Understands[any.Method[FT], Apply[Log[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Log[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Log[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.log(command.arguments(0), command.arguments(1))) + implicit val canLog: Understands[any.Method, Apply[Log[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Log[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Log[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.log(command.arguments(0), command.arguments(1))) + } } - } - implicit val canSin: Understands[any.Method[FT], Apply[Sin[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Sin[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Sin[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.sin(command.arguments.head)) + implicit val canSin: Understands[any.Method, Apply[Sin[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Sin[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Sin[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.sin(command.arguments.head)) + } } - } - implicit val canCos: Understands[any.Method[FT], Apply[Cos[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Cos[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Cos[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.cos(command.arguments.head)) + implicit val canCos: Understands[any.Method, Apply[Cos[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Cos[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Cos[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.cos(command.arguments.head)) + } } - } - implicit val canEuler: Understands[any.Method[FT], EulersNumber[any.Expression[FT]]] = - new Understands[any.Method[FT], EulersNumber[any.Expression[FT]]] { - def perform(context: any.Method[FT], command: EulersNumber[any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.eulersNumber()) + implicit val canEuler: Understands[any.Method, EulersNumber[any.Expression]] = + new Understands[any.Method, EulersNumber[any.Expression]] { + def perform(context: any.Method, command: EulersNumber[any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.eulersNumber()) + } } - } - implicit val canPi: Understands[any.Method[FT], Pi[any.Expression[FT]]] = - new Understands[any.Method[FT], Pi[any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Pi[any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.pi()) + implicit val canPi: Understands[any.Method, Pi[any.Expression]] = + new Understands[any.Method, Pi[any.Expression]] { + def perform(context: any.Method, command: Pi[any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.pi()) + } } - } - implicit val canAbs: Understands[any.Method[FT], Apply[Abs[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Abs[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Abs[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.abs(command.arguments.head)) + implicit val canAbs: Understands[any.Method, Apply[Abs[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Abs[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Abs[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.abs(command.arguments.head)) + } } - } - implicit val canFloor: Understands[any.Method[FT], Apply[Floor[T], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[Floor[T], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[Floor[T], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.floor(command.arguments.head)) + implicit val canFloor: Understands[any.Method, Apply[Floor[T], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[Floor[T], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[Floor[T], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, realArithmeticOpsFactory.floor(command.arguments.head)) + } } - } + } + def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] } - def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] + + val realArithmeticInMethods: RealArithmeticInMethods = new RealArithmeticInMethods {} } object RealArithmetic { - type WithBase[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: RealArithmeticOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType], T] = RealArithmetic[FT, FactoryType, T] { val base: B } - def apply[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: RealArithmeticOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType], T](_base: B): WithBase[FT, FactoryType, _base.type, T] = new RealArithmetic[FT, FactoryType, T] { - val base: _base.type = _base - } -} - -object RealArithmeticOps { - trait SqrtOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait PowOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait LogOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait SinOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait CosOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait AbsOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait FloorOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] + type WithBase[T, AST <: RealArithmeticAST, B <: AnyParadigm.WithAST[AST]] = RealArithmetic[AST, B, T] {val _base: B} - trait EulersNumber[FT <: OperatorExpressionOps.FinalTypes] extends any.Expression[FT] - - trait Pi[FT <: OperatorExpressionOps.FinalTypes] extends any.Expression[FT] - - - trait Factory[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Factory[FT] { - def sqrtOp(): SqrtOp[FT] - def powOp(): PowOp[FT] - def logOp(): LogOp[FT] - def sinOp(): SinOp[FT] - def cosOp(): CosOp[FT] - def absOp(): AbsOp[FT] - def floorOp(): FloorOp[FT] - - def pi(): Pi[FT] - def eulersNumber(): EulersNumber[FT] - - def sqrt(of: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(sqrtOp(), of) - def pow(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(powOp(), left, right) - - def log(of: any.Expression[FT], base: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(logOp(), of, base) // FIXME: unaryExpression(logOp(), of) - def sin(of: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(sinOp(), of) - def cos(of: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(cosOp(), of) - def abs(of: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(absOp(), of) - def floor(of: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(floorOp(), of) - } -} \ No newline at end of file + def apply[T, AST <: RealArithmeticAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[T, AST, B] = new RealArithmetic[AST, B, T](_base) {} +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmeticAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmeticAST.scala new file mode 100644 index 00000000..83a72a59 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/RealArithmeticAST.scala @@ -0,0 +1,45 @@ +package org.combinators.ep.language.inbetween.ffi + +trait RealArithmeticAST extends OperatorExpressionOpsAST { + object realArithmeticOps { + trait SqrtOp extends operatorExpressions.Operator + trait PowOp extends operatorExpressions.Operator + trait LogOp extends operatorExpressions.Operator + trait SinOp extends operatorExpressions.Operator + trait CosOp extends operatorExpressions.Operator + trait AbsOp extends operatorExpressions.Operator + trait FloorOp extends operatorExpressions.Operator + trait EulersNumber extends any.Expression + trait Pi extends any.Expression + + trait Factory { + def sqrtOp(): SqrtOp + def powOp(): PowOp + def logOp(): LogOp + def sinOp(): SinOp + def cosOp(): CosOp + def absOp(): AbsOp + def floorOp(): FloorOp + + def pi(): Pi + def eulersNumber(): EulersNumber + + def sqrt(of: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(sqrtOp(), of) + def pow(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(powOp(), left, right) + + def log(of: any.Expression, base: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(logOp(), of, base) // FIXME: unaryExpression(logOp(), of) + def sin(of: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(sinOp(), of) + def cos(of: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(cosOp(), of) + def abs(of: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(absOp(), of) + def floor(of: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(floorOp(), of) + } + } + val realArithmeticOpsFactory: realArithmeticOps.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/StringAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/StringAST.scala new file mode 100644 index 00000000..07be1b7f --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/StringAST.scala @@ -0,0 +1,24 @@ +package org.combinators.ep.language.inbetween.ffi + +trait StringAST extends OperatorExpressionOpsAST { + object stringOps { + trait ToStringOp extends operatorExpressions.Operator + trait AppendStringOp extends operatorExpressions.Operator + trait StringLengthOp extends operatorExpressions.Operator + + + trait Factory { + def toStringOp(): ToStringOp + def appendStringOp(): AppendStringOp + def stringLengthOp(): StringLengthOp + + def toString(exp: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(toStringOp(), exp) + def appendString(left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = + operatorExpressionsFactory.binaryExpression(appendStringOp(), left, right) + def stringLength(exp: any.Expression): operatorExpressions.UnaryExpression = + operatorExpressionsFactory.unaryExpression(stringLengthOp(), exp) + } + } + val stringOpsFactory: stringOps.Factory +} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Strings.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Strings.scala index 5f4ba0d0..567b8b33 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Strings.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Strings.scala @@ -1,64 +1,51 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.ffi -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.Apply +/*DI:LI:AI*/ + +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{GetStringLength, StringAppend, ToString, Strings as Strs} +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.Command.Generator import org.combinators.ep.language.inbetween.any import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.paradigm.ffi.{GetStringLength, StringAppend, ToString, Strings => Strs} // cannot find 'strings' -trait Strings[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: StringOps.Factory[FT]] extends Strs[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory - - val stringCapabilities: StringCapabilities = new StringCapabilities { - implicit val canGetStringLength: Understands[any.Method[FT], Apply[GetStringLength, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[GetStringLength, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[GetStringLength, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.stringLength(command.arguments.head)) +trait Strings[AST <: StringAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait StringsInMethods extends Strs[_base.ast.any.Method] { + override val base: _base.type = _base + + import base.ast.any + import base.ast.stringOpsFactory + + val stringCapabilities: StringCapabilities = new StringCapabilities { + implicit val canGetStringLength: Understands[any.Method, Apply[GetStringLength, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[GetStringLength, any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[GetStringLength, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, stringOpsFactory.stringLength(command.arguments.head)) + } } - } - implicit val canAppend: Understands[any.Method[FT], Apply[StringAppend, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[StringAppend, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[StringAppend, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, command.arguments.tail.foldLeft(command.arguments.head){case (r, l) => factory.appendString(r, l)}) + implicit val canAppend: Understands[any.Method, Apply[StringAppend, any.Expression, any.Expression]] = + new Understands[any.Method, Apply[StringAppend, any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[StringAppend, any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, command.arguments.tail.foldLeft(command.arguments.head) { case (r, l) => stringOpsFactory.appendString(r, l) }) + } } - } - implicit val canToStringInCtxt: Understands[any.Method[FT], Apply[ToString[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[ToString[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[ToString[any.Type[FT]], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.toString(command.arguments.head)) + implicit val canToStringInCtxt: Understands[any.Method, Apply[ToString[any.Type], any.Expression, any.Expression]] = + new Understands[any.Method, Apply[ToString[any.Type], any.Expression, any.Expression]] { + def perform(context: any.Method, command: Apply[ToString[any.Type], any.Expression, any.Expression]): (any.Method, any.Expression) = { + (context, stringOpsFactory.toString(command.arguments.head)) + } } - } + } + def enable(): Generator[any.Project, Unit] = Command.skip[any.Project] } - def enable(): Generator[any.Project[FT], Unit] = Command.skip[any.Project[FT]] + + val stringsInMethods: StringsInMethods = new StringsInMethods {} } object Strings { - type WithBase[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: StringOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Strings[FT, FactoryType] { val base: B } - def apply[FT <: OperatorExpressionOps.FinalTypes, FactoryType <: StringOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Strings[FT, FactoryType] { - val base: _base.type = _base - } + type WithBase[AST <: StringAST, B <: AnyParadigm.WithAST[AST]] = Strings[AST, B] {} + def apply[AST <: StringAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Strings[AST, B](_base) {} } -object StringOps { - trait ToStringOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait AppendStringOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - trait StringLengthOp[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Operator[FT] - - - trait Factory[FT <: OperatorExpressionOps.FinalTypes] extends OperatorExpressionOps.Factory[FT] { - def toStringOp(): ToStringOp[FT] - def appendStringOp(): AppendStringOp[FT] - def stringLengthOp(): StringLengthOp[FT] - - def toString(exp: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(toStringOp(), exp) - def appendString(left: any.Expression[FT], right: any.Expression[FT]): OperatorExpressionOps.BinaryExpression[FT] = - binaryExpression(appendStringOp(), left, right) - def stringLength(exp: any.Expression[FT]): OperatorExpressionOps.UnaryExpression[FT] = - unaryExpression(stringLengthOp(), exp) - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Trees.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Trees.scala deleted file mode 100644 index fb745a27..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/Trees.scala +++ /dev/null @@ -1,80 +0,0 @@ -package org.combinators.ep.language.inbetween.ffi /*DI:LI:AI*/ - -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.language.inbetween.{any, polymorphism} -import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax -import org.combinators.ep.generator.paradigm.ffi.{CreateLeaf, CreateNode, Trees => Trs} - -// cannot find 'trees' -trait Trees[FT <: TreeOps.FinalTypes, FactoryType <: TreeOps.Factory[FT]] extends Trs[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory - val treeLibrary: Map[Seq[any.Name[FT]], Generator[any.CompilationUnit[FT], Unit]] - - override val treeCapabilities: TreeCapabilities = new TreeCapabilities { - implicit val canCreateLeaf: Understands[any.Method[FT], Apply[CreateLeaf[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[CreateLeaf[any.Type[FT]], any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[CreateLeaf[any.Type[FT]], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.createLeaf(command.functional.valueType, command.arguments.head)) - } - } - implicit val canCreateNode: Understands[any.Method[FT], Apply[CreateNode, any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[CreateNode, any.Expression[FT], any.Expression[FT]]] { - def perform(context: any.Method[FT], command: Apply[CreateNode, any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.createNode(command.arguments.head, command.arguments.tail)) - } - } - } - - override def enable(): Generator[any.Project[FT], Unit] = { - import base.projectCapabilities._ - import syntax.forEach - for { - _ <- forEach(treeLibrary.toSeq){ case (qualifiedName, compilationUnit) => - addCompilationUnit(compilationUnit, qualifiedName: _*) - } - } yield () - } -} - -object Trees { - type WithBase[FT <: TreeOps.FinalTypes, FactoryType <: TreeOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Trees[FT, FactoryType] { val base: B } - def apply[FT <: TreeOps.FinalTypes, FactoryType <: TreeOps.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]]( - _base: B)( - _treeLibrary: Map[Seq[any.Name[FT]], Generator[any.CompilationUnit[FT], Unit]] - ): WithBase[FT, FactoryType, _base.type] = new Trees[FT, FactoryType] { - val base: _base.type = _base - val treeLibrary = _treeLibrary - } -} - -object TreeOps { - - trait FinalTypes extends OperatorExpressionOps.FinalTypes with polymorphism.FinalTypes { - type CreateLeaf <: Type - type CreateNodeExpr <: Expression - } - trait CreateLeaf[FT <: FinalTypes] extends any.Type[FT] { - def getSelfCreateLeaf: finalTypes.CreateLeaf - } - - trait CreateNodeExpr[FT <: FinalTypes] extends any.Expression[FT] { - def getSelfCreateNodeExpr: finalTypes.CreateNodeExpr - } - trait Factory[FT <: FinalTypes] extends OperatorExpressionOps.Factory[FT] with polymorphism.Factory[FT] { - def createNodeExpr(): CreateNodeExpr[FT] - def createLeaf(): CreateLeaf[FT] - - def createNode(label: any.Expression[FT], children: Seq[any.Expression[FT]]): any.ApplyExpression[FT] = - applyExpression(createNodeExpr(), label +: children) - - def createLeaf(tpe: any.Type[FT], value: any.Expression[FT]): any.ApplyExpression[FT] = - applyExpression(typeReferenceExpression(typeApplication(createLeaf(), Seq(tpe))), Seq(value)) - - implicit def convert(other: CreateLeaf[FT]): CreateLeaf[FT] - implicit def convert(other: CreateNodeExpr[FT]): CreateNodeExpr[FT] - } -} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalAST.scala new file mode 100644 index 00000000..5694d186 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalAST.scala @@ -0,0 +1,224 @@ +package org.combinators.ep.language.inbetween.functional + +import org.combinators.cogen.{FileWithPath, TypeRep} +import org.combinators.cogen.Command.Generator +import org.combinators.ep.language.inbetween.any.AnyAST + +trait FunctionalAST extends AnyAST { + object functional { + object anyOverrides { + trait FinalTypes extends any.FinalTypes { + type Project <: anyOverrides.Project + type CompilationUnit <: anyOverrides.CompilationUnit + type Method <: anyOverrides.Method + } + + trait Project extends any.Project { + def adtTypeLookupMap: TypeRep => Generator[AlgebraicDataType, any.Type] = Map.empty + def functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + + def addTypeLookupsForFunctions(lookups: TypeRep => Option[Generator[any.Method, any.Type]]): any.Project = + copyAsFunctionalProject(functionTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.functionTypeLookupMap(tpeRep))) + + def addTypeLookupsForAlgebraicDataTypes(lookups: TypeRep => Option[Generator[AlgebraicDataType, any.Type]]): any.Project = + copyAsFunctionalProject(adtTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.adtTypeLookupMap(tpeRep))) + + override def copy( + compilationUnits: Set[any.CompilationUnit], + customFiles: Seq[FileWithPath] + ): any.Project = copyAsFunctionalProject(compilationUnits, customFiles) + + def copyAsFunctionalProject( + compilationUnits: Set[any.CompilationUnit] = this.compilationUnits, + customFiles: Seq[FileWithPath] = this.customFiles, + adtTypeLookupMap: TypeRep => Generator[AlgebraicDataType, any.Type] = this.adtTypeLookupMap, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.functionTypeLookupMap, + ): Project = functionalFactory.functionalProject(compilationUnits, customFiles, adtTypeLookupMap, functionTypeLookupMap) + } + + trait CompilationUnit extends any.CompilationUnit { + def adts: Seq[AlgebraicDataType] = Seq.empty + def functions: Seq[any.Method] = Seq.empty + + def adtTypeLookupMap: TypeRep => Generator[AlgebraicDataType, any.Type] = Map.empty + def functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + + def resolveImport(tpe: any.Type): Seq[any.Import] + def resolveImport(exp: any.Expression): Seq[any.Import] + + def addTypeLookupsForFunctions(lookups: TypeRep => Option[Generator[any.Method, any.Type]]): any.CompilationUnit = + copyAsFunctionalCompilationUnit(functionTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.functionTypeLookupMap(tpeRep))) + + def addTypeLookupsForAlgebraicDataTypes(lookups: TypeRep => Option[Generator[AlgebraicDataType, any.Type]]): any.CompilationUnit = + copyAsFunctionalCompilationUnit(adtTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.adtTypeLookupMap(tpeRep))) + + override def initializeInProject(project: any.Project): any.CompilationUnit = { + import factory.convert + val withLookups = copyAsFunctionalCompilationUnit( + adtTypeLookupMap = project.adtTypeLookupMap, + functionTypeLookupMap = project.functionTypeLookupMap + ) + withLookups.copyAsFunctionalCompilationUnit( + tests = withLookups.tests.map(_.initializeInCompilationUnit(withLookups)) + ) + } + + override def copy( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + tests: Seq[any.TestSuite] = this.tests, + ): any.CompilationUnit = copyAsFunctionalCompilationUnit(name, imports, tests = tests) + + def copyAsFunctionalCompilationUnit( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + adtTypeLookupMap: TypeRep => Generator[AlgebraicDataType, any.Type] = this.adtTypeLookupMap, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.functionTypeLookupMap, + adts: Seq[AlgebraicDataType] = this.adts, + functions: Seq[any.Method] = this.functions, + tests: Seq[any.TestSuite] = this.tests, + ): CompilationUnit = functionalFactory.funCompilationUnit(name, imports, adtTypeLookupMap, functionTypeLookupMap, adts, functions, tests) + } + + trait Method extends any.Method { + def resolveImport(exp: any.Expression): Seq[any.Import] + + def findMethod(name: Seq[any.Name]): any.Expression + def findType(name: Seq[any.Name]): any.Type + } + + trait Factory extends any.Factory { + override def project(compilationUnits: Set[any.CompilationUnit], customFiles: Seq[FileWithPath]): any.Project = + functionalFactory.functionalProject(compilationUnits = compilationUnits, customFiles = customFiles, adtTypeLookupMap = Map.empty, functionTypeLookupMap = Map.empty) + override def compilationUnit(name: Seq[any.Name], imports: Seq[any.Import], tests: Seq[any.TestSuite]): any.CompilationUnit = + functionalFactory.funCompilationUnit(name, imports, adtTypeLookupMap = Map.empty, functionTypeLookupMap = Map.empty, adts = Seq.empty, functions = Seq.empty, tests = tests) + } + } + + trait FinalTypes { + type AlgebraicDataType <: functional.AlgebraicDataType + type TypeConstructor <: functional.TypeConstructor + type TypeInstantiationExpression <: functional.TypeInstantiationExpression + type ADTReferenceType <: functional.ADTReferenceType + } + + trait AlgebraicDataType { + def getSelfAlgebraicDataType: functionalFinalTypes.AlgebraicDataType + + def name: any.Name + def imports: Seq[any.Import] = Seq.empty + def typeConstructors: Seq[TypeConstructor] = Seq.empty + + def typeLookupMap: TypeRep => Generator[AlgebraicDataType, any.Type] = Map.empty + + def toTargetLanguageType(tpe: TypeRep): Generator[AlgebraicDataType, any.Type] = typeLookupMap(tpe) + + def addTypeLookupsForAlgebraicDataTypes(lookups: TypeRep => Option[Generator[AlgebraicDataType, any.Type]]): AlgebraicDataType = { + copy(typeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.typeLookupMap(tpeRep))) + } + + def findType(name: Seq[any.Name]): any.Type + + def resolveImport(tpe: any.Type): Seq[any.Import] + def resolveImport(exp: any.Expression): Seq[any.Import] + def getFreshName(basedOn: any.Name): any.Name + + def copy( + name: any.Name = this.name, + imports: Seq[any.Import] = this.imports, + typeConstructors: Seq[TypeConstructor] = this.typeConstructors, + typeLookupMap: TypeRep => Generator[AlgebraicDataType, any.Type] = this.typeLookupMap, + ): AlgebraicDataType = functionalFactory.adt( + name = name, + imports = imports, + typeConstructors = typeConstructors, + typeLookupMap = typeLookupMap, + ) + } + + trait TypeConstructor { + def getSelfTypeConstructor: functionalFinalTypes.TypeConstructor + + def name: any.Name + def parameters: Seq[(any.Name, any.Type)] + + def copy( + name: any.Name = this.name, + parameters: Seq[(any.Name, any.Type)] = this.parameters + ): TypeConstructor = functionalFactory.typeConstructor(name, parameters) + } + + trait TypeInstantiationExpression extends any.Expression { + def getSelfTypeInstantiationExpression: functionalFinalTypes.TypeInstantiationExpression + + def tpe: any.Type + def constructorName: Seq[any.Name] + def constructorArguments: Seq[any.Expression] + + def copy( + tpe: any.Type = this.tpe, + constructorName: Seq[any.Name] = this.constructorName, + constructorArguments: Seq[any.Expression] = this.constructorArguments + ): TypeInstantiationExpression = functionalFactory.typeInstantiationExpression(tpe, constructorName, constructorArguments) + } + + trait ADTReferenceType extends any.Type { + def getSelfADTReferenceType: functionalFinalTypes.ADTReferenceType + + def qualifiedTypeName: Seq[any.Name] + + def copy( + qualifiedTypeName: Seq[any.Name] = this.qualifiedTypeName + ): ADTReferenceType = functionalFactory.adtReferenceType(qualifiedTypeName *) + } + + trait Factory { + def functionalProject( + compilationUnits: Set[any.CompilationUnit] = Set.empty, + customFiles: Seq[FileWithPath] = Seq.empty, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + ): anyOverrides.Project + + def funCompilationUnit( + name: Seq[any.Name], + imports: Seq[any.Import], + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + adts: Seq[functional.AlgebraicDataType] = Seq.empty, + functions: Seq[any.Method] = Seq.empty, + tests: Seq[any.TestSuite] = Seq.empty, + ): anyOverrides.CompilationUnit + + def adt( + name: any.Name, + imports: Seq[any.Import] = Seq.empty, + typeConstructors: Seq[TypeConstructor] = Seq.empty, + typeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + ): AlgebraicDataType + + def typeConstructor( + name: any.Name, + parameters: Seq[(any.Name, any.Type)] = Seq.empty + ): TypeConstructor + + def typeInstantiationExpression( + tpe: any.Type, + constructorName: Seq[any.Name], + constructorArguments: Seq[any.Expression] = Seq.empty, + ): TypeInstantiationExpression + + def adtReferenceType(qualifiedTypeName: any.Name*): ADTReferenceType + + implicit def convert(other: AlgebraicDataType): functionalFinalTypes.AlgebraicDataType = other.getSelfAlgebraicDataType + implicit def convert(other: TypeConstructor): functionalFinalTypes.TypeConstructor = other.getSelfTypeConstructor + implicit def convert(other: TypeInstantiationExpression): functionalFinalTypes.TypeInstantiationExpression = other.getSelfTypeInstantiationExpression + implicit def convert(other: ADTReferenceType): functionalFinalTypes.ADTReferenceType = other.getSelfADTReferenceType + } + } + + val finalTypes: functional.anyOverrides.FinalTypes + val functionalFinalTypes: functional.FinalTypes + val factory: functional.anyOverrides.Factory + val functionalFactory: functional.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalParadigm.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalParadigm.scala index 04fd79ee..5e528494 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalParadigm.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/FunctionalParadigm.scala @@ -1,26 +1,29 @@ package org.combinators.ep.language.inbetween.functional /*DI:LI:AI*/ -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, FileWithPath, Understands, paradigm} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AddImport, AddMethod, AddType, AddTypeConstructor, AddTypeLookup, FindMethod, FindType, InstantiateType, ResolveImport, ToTargetLanguageType, Functional as FP} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, FileWithPath, Understands, paradigm} import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.paradigm.{AddImport, AddMethod, AddType, AddTypeConstructor, AddTypeLookup, FindMethod, FindType, InstantiateType, ResolveImport, ToTargetLanguageType, Functional => FP} import org.combinators.ep.language.inbetween.any -trait FunctionalParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends FP { - val base: AnyParadigm.WithFT[FT, FactoryType] - - import base.{FT => _, _} - import syntax._ - - lazy val factory: base.factory.type = base.factory - type TypeContext = AlgebraicDataType[FT] +trait FunctionalParadigm[AST <: FunctionalAST, B](val base: AnyParadigm.WithAST[AST] & B) extends FP { + import base.ast.any + import base.ast.factory + import base.ast.functionalFactory + import base.ast.functional.* + import base.ast.any.* + import base.ProjectContext + import base.CompilationUnitContext + import base.MethodBodyContext + + type TypeContext = AlgebraicDataType val compilationUnitCapabilities: CompilationUnitCapabilities = new CompilationUnitCapabilities { implicit val canAddTypeInCompilationUnit: Understands[CompilationUnitContext, AddType[Name, TypeContext]] = new Understands[CompilationUnitContext, AddType[Name, TypeContext]] { def perform(context: CompilationUnit, command: AddType[Name, TypeContext]): (CompilationUnit, Unit) = { val converted = factory.convert(context) - val emptyType = factory.adt( + val emptyType = functionalFactory.adt( name = command.name, typeLookupMap = converted.adtTypeLookupMap) var (generatedType, result) = Command.runGenerator(command.tpeGen, emptyType) @@ -41,13 +44,13 @@ trait FunctionalParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends F } implicit val canResolveExpressionImportInCompilationUnit: Understands[CompilationUnitContext, ResolveImport[Import, Expression]] = new Understands[CompilationUnitContext, ResolveImport[Import, Expression]] { - override def perform(context: any.CompilationUnit[FT], command: ResolveImport[any.Import[FT], any.Expression[FT]]): (any.CompilationUnit[FT], Option[any.Import[FT]]) = { + override def perform(context: any.CompilationUnit, command: ResolveImport[any.Import, any.Expression]): (any.CompilationUnit, Option[any.Import]) = { (context, factory.convert(context).resolveImport(command.forElem).headOption) } } implicit val canResolveTypeImportInCompilationUnit: Understands[CompilationUnitContext, ResolveImport[Import, Type]] = new Understands[CompilationUnitContext, ResolveImport[Import, Type]] { - override def perform(context: any.CompilationUnit[FT], command: ResolveImport[any.Import[FT], any.Type[FT]]): (any.CompilationUnit[FT], Option[any.Import[FT]]) = { + override def perform(context: any.CompilationUnit, command: ResolveImport[any.Import, any.Type]): (any.CompilationUnit, Option[any.Import]) = { (context, factory.convert(context).resolveImport(command.forElem).headOption) } } @@ -55,36 +58,36 @@ trait FunctionalParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends F val typeCapabilities: TypeCapabilities = new TypeCapabilities { implicit val canAddTypeConstructorInType: Understands[TypeContext, AddTypeConstructor[Name, Type]] = new Understands[TypeContext, AddTypeConstructor[Name, Type]] { - override def perform(context: AlgebraicDataType[FT], command: AddTypeConstructor[any.Name[FT], any.Type[FT]]): (AlgebraicDataType[FT], Unit) = { - (context.copy(typeConstructors = context.typeConstructors :+ factory.typeConstructor(command.name, command.parameters)), ()) + override def perform(context: AlgebraicDataType, command: AddTypeConstructor[any.Name, any.Type]): (AlgebraicDataType, Unit) = { + (context.copy(typeConstructors = context.typeConstructors :+ functionalFactory.typeConstructor(command.name, command.parameters)), ()) } } implicit val canTranslateTypeInType: Understands[TypeContext, ToTargetLanguageType[Type]] = new Understands[TypeContext, ToTargetLanguageType[Type]] { - override def perform(context: AlgebraicDataType[FT], command: ToTargetLanguageType[Type]): (AlgebraicDataType[FT], command.Result) = { + override def perform(context: AlgebraicDataType, command: ToTargetLanguageType[Type]): (AlgebraicDataType, command.Result) = { Command.runGenerator(context.toTargetLanguageType(command.tpe), context) } } implicit val canAddImportInType: Understands[TypeContext, AddImport[Import]] = new Understands[TypeContext, AddImport[Import]] { - override def perform(context: AlgebraicDataType[FT], command: AddImport[any.Import[FT]]): (AlgebraicDataType[FT], Unit) = { + override def perform(context: AlgebraicDataType, command: AddImport[any.Import]): (AlgebraicDataType, Unit) = { (context.copy(imports = context.imports :+ command.imp), ()) } } implicit val canResolveTypeImportInType: Understands[TypeContext, ResolveImport[Import, Type]] = new Understands[TypeContext, ResolveImport[Import, Type]] { - override def perform(context: AlgebraicDataType[FT], command: ResolveImport[any.Import[FT], any.Type[FT]]): (AlgebraicDataType[FT], Option[any.Import[FT]]) = { + override def perform(context: AlgebraicDataType, command: ResolveImport[any.Import, any.Type]): (AlgebraicDataType, Option[any.Import]) = { (context, context.resolveImport(command.forElem).headOption) } } implicit val canResolveExpressionImportInType: Understands[TypeContext, ResolveImport[Import, Expression]] = new Understands[TypeContext, ResolveImport[Import, Expression]] { - override def perform(context: AlgebraicDataType[FT], command: ResolveImport[any.Import[FT], any.Expression[FT]]): (AlgebraicDataType[FT], Option[any.Import[FT]]) = { + override def perform(context: AlgebraicDataType, command: ResolveImport[any.Import, any.Expression]): (AlgebraicDataType, Option[any.Import]) = { (context, context.resolveImport(command.forElem).headOption) } } implicit val canFindTypeInType: Understands[TypeContext, FindType[Name, Type]] = new Understands[TypeContext, FindType[Name, Type]] { - override def perform(context: AlgebraicDataType[FT], command: FindType[any.Name[FT], any.Type[FT]]): (AlgebraicDataType[FT], any.Type[FT]) = { + override def perform(context: AlgebraicDataType, command: FindType[any.Name, any.Type]): (AlgebraicDataType, any.Type) = { (context, context.findType(command.name)) } } @@ -92,25 +95,25 @@ trait FunctionalParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends F val methodBodyCapabilities: MethodBodyCapabilities = new MethodBodyCapabilities { implicit val canInstantiateTypeInMethod: Understands[MethodBodyContext, InstantiateType[Type, Name, Expression]] = new Understands[MethodBodyContext, InstantiateType[Type, Name, Expression]] { - override def perform(context: any.Method[FT], command: InstantiateType[any.Type[FT], any.Name[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.typeInstantiationExpression(command.tpe, Seq(command.constructor), command.arguments)) + override def perform(context: any.Method, command: InstantiateType[any.Type, any.Name, any.Expression]): (any.Method, any.Expression) = { + (context, functionalFactory.typeInstantiationExpression(command.tpe, Seq(command.constructor), command.arguments)) } } implicit val canResolveExpressionImportInMethod: Understands[MethodBodyContext, ResolveImport[Import, Expression]] = new Understands[MethodBodyContext, ResolveImport[Import, Expression]] { - override def perform(context: any.Method[FT], command: ResolveImport[any.Import[FT], any.Expression[FT]]): (any.Method[FT], Option[any.Import[FT]]) = { + override def perform(context: any.Method, command: ResolveImport[any.Import, any.Expression]): (any.Method, Option[any.Import]) = { (context, factory.convert(context).resolveImport(command.forElem).headOption) } } implicit val canFindMethodInMethod: Understands[MethodBodyContext, FindMethod[Name, Expression]] = new Understands[MethodBodyContext, FindMethod[Name, Expression]] { - override def perform(context: any.Method[FT], command: FindMethod[any.Name[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { + override def perform(context: any.Method, command: FindMethod[any.Name, any.Expression]): (any.Method, any.Expression) = { (context, factory.convert(context).findMethod(command.name)) } } implicit val canFindTypeInMethod: Understands[MethodBodyContext, FindType[Name, Type]] = new Understands[MethodBodyContext, FindType[Name, Type]] { - override def perform(context: any.Method[FT], command: FindType[any.Name[FT], any.Type[FT]]): (any.Method[FT], any.Type[FT]) = { + override def perform(context: any.Method, command: FindType[any.Name, any.Type]): (any.Method, any.Type) = { (context, factory.convert(context).findType(command.name)) } } @@ -118,7 +121,7 @@ trait FunctionalParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends F val projectCapabilities: ProjectCapabilities = new ProjectCapabilities { implicit val canAddTypeLookupForTypesInProject: Understands[ProjectContext, AddTypeLookup[TypeContext, Type]] = new Understands[ProjectContext, AddTypeLookup[TypeContext, Type]] { - override def perform(context: any.Project[FT], command: AddTypeLookup[AlgebraicDataType[FT], any.Type[FT]]): (any.Project[FT], Unit) = { + override def perform(context: any.Project, command: AddTypeLookup[AlgebraicDataType, any.Type]): (any.Project, Unit) = { (factory.convert(context).addTypeLookupsForAlgebraicDataTypes((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } @@ -126,8 +129,6 @@ trait FunctionalParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends F } object FunctionalParadigm { - type WithBase[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = FunctionalParadigm[FT, FactoryType] { val base: B } - def apply[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new FunctionalParadigm[FT, FactoryType] { - val base: _base.type = _base - } + type WithBase[AST <: FunctionalAST, B <: AnyParadigm.WithAST[AST]] = FunctionalParadigm[AST, B] {} + def apply[AST <: FunctionalAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new FunctionalParadigm[AST, B](_base) {} } \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/Functional.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/Functional.scala index 033891bb..f0ffd0df 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/Functional.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/Functional.scala @@ -1,103 +1,106 @@ package org.combinators.ep.language.inbetween.functional.control -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands, paradigm} -import org.combinators.ep.generator.paradigm.{Apply, Reify, control} -import org.combinators.ep.generator.paradigm.control.{DeclareFunVariable => DFV, Functional => Fun} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.control.* +import org.combinators.cogen.paradigm.control.{DeclareFunVariable as DFV, Functional as Fun} +import org.combinators.cogen.paradigm.{Apply, IfThenElse, Reify, control} +import org.combinators.cogen.{Command, Understands, paradigm} import org.combinators.ep.language.inbetween.any import org.combinators.ep.language.inbetween.any.AnyParadigm -trait Functional[FT <: FinalTypes, FactoryType <: Factory[FT]] extends Fun[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] +trait Functional[AST <: FunctionalControlAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait FunctionalInMethods extends control.Functional[_base.ast.any.Method] { + override val base: _base.type = _base - import base.factory + import base.ast.{any, factory, functionalControlFactory} - type Ctxt = any.Method[FT] - override type PatternContext = org.combinators.ep.language.inbetween.functional.control.PatternContext[FT] + type Ctxt = any.Method + override type PatternContext = base.ast.funcontrol.PatternContext - val lambdaCapabilities: LambdaCapabilities = new LambdaCapabilities { - implicit val canLambda: Understands[any.Method[FT], control.Lambda[any.Name[FT], any.Type[FT], any.Method[FT], any.Expression[FT]]] = new Understands[any.Method[FT], control.Lambda[any.Name[FT], any.Type[FT], any.Method[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: control.Lambda[any.Name[FT], any.Type[FT], any.Method[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val args = command.variables.map { case (pname, _tpe) => (pname, factory.argumentExpression(pname)) }.toMap - val (updatedCtxt, body) = Command.runGenerator(command.body(args), context) - (updatedCtxt, factory.lambda(command.variables, body)) + val lambdaCapabilities: LambdaCapabilities = new LambdaCapabilities { + implicit val canLambda: Understands[any.Method, Lambda[any.Name, any.Type, any.Method, any.Expression]] = new Understands[any.Method, Lambda[any.Name, any.Type, any.Method, any.Expression]] { + override def perform(context: any.Method, command: Lambda[any.Name, any.Type, any.Method, any.Expression]): (any.Method, any.Expression) = { + val args = command.variables.map { case (pname, _tpe) => (pname, factory.argumentExpression(pname)) }.toMap + val (updatedCtxt, body) = Command.runGenerator(command.body(args), context) + (updatedCtxt, functionalControlFactory.lambda(command.variables, body)) + } } } - } - val functionalCapabilities: FunctionalCapabilities = new FunctionalCapabilities { - implicit val canDeclareVar: Understands[any.Method[FT], DFV[any.Method[FT], any.Name[FT], any.Type[FT], any.Expression[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], DFV[any.Method[FT], any.Name[FT], any.Type[FT], any.Expression[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: DFV[any.Method[FT], any.Name[FT], any.Type[FT], any.Expression[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val (resContext, inExp) = Command.runGenerator(command.inBlk(factory.argumentExpression(command.name)), context) - (resContext, factory.declareFunVariable(command.name, command.tpe, isRecursive = false, command.initialization, inExp)) + val functionalCapabilities: FunctionalCapabilities = new FunctionalCapabilities { + implicit val canDeclareVar: Understands[any.Method, DeclareFunVariable[any.Method, any.Name, any.Type, any.Expression, any.Expression]] = + new Understands[any.Method, DeclareFunVariable[any.Method, any.Name, any.Type, any.Expression, any.Expression]] { + override def perform(context: any.Method, command: DeclareFunVariable[any.Method, any.Name, any.Type, any.Expression, any.Expression]): (any.Method, any.Expression) = { + val (resContext, inExp) = Command.runGenerator(command.inBlk(factory.argumentExpression(command.name)), context) + (resContext, functionalControlFactory.declareFunVariable(command.name, command.tpe, isRecursive = false, command.initialization, inExp)) + } } - } - implicit val canDeclareRecVar: Understands[any.Method[FT], DFV[any.Method[FT], any.Name[FT], any.Type[FT], any.Expression[FT] => Generator[any.Method[FT], any.Expression[FT]], any.Expression[FT]]] = - new Understands[any.Method[FT], DFV[any.Method[FT], any.Name[FT], any.Type[FT], any.Expression[FT] => Generator[any.Method[FT], any.Expression[FT]], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: DFV[any.Method[FT], any.Name[FT], any.Type[FT], any.Expression[FT] => Generator[any.Method[FT], any.Expression[FT]], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val (initContext, initExp) = Command.runGenerator(command.initialization(factory.argumentExpression(command.name)), context) - val (resContext, inExp) = Command.runGenerator(command.inBlk(factory.argumentExpression(command.name)), initContext) - (resContext, factory.declareFunVariable(command.name, command.tpe, isRecursive = true, initExp, inExp)) + implicit val canDeclareRecVar: Understands[any.Method, DeclareFunVariable[any.Method, any.Name, any.Type, any.Expression => Generator[any.Method, any.Expression], any.Expression]] = + new Understands[any.Method, DeclareFunVariable[any.Method, any.Name, any.Type, any.Expression => Generator[any.Method, any.Expression], any.Expression]] { + override def perform(context: any.Method, command: DeclareFunVariable[any.Method, any.Name, any.Type, any.Expression => Generator[any.Method, any.Expression], any.Expression]): (any.Method, any.Expression) = { + val (initContext, initExp) = Command.runGenerator(command.initialization(factory.argumentExpression(command.name)), context) + val (resContext, inExp) = Command.runGenerator(command.inBlk(factory.argumentExpression(command.name)), initContext) + (resContext, functionalControlFactory.declareFunVariable(command.name, command.tpe, isRecursive = true, initExp, inExp)) + } } - } - implicit val canIfThenElse: Understands[any.Method[FT], paradigm.IfThenElse[any.Expression[FT], Generator[any.Method[FT], any.Expression[FT]], Generator[any.Method[FT], any.Expression[FT]], any.Expression[FT]]] = - new Understands[any.Method[FT], paradigm.IfThenElse[any.Expression[FT], Generator[any.Method[FT], any.Expression[FT]], Generator[any.Method[FT], any.Expression[FT]], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: paradigm.IfThenElse[any.Expression[FT], Generator[any.Method[FT], any.Expression[FT]], Generator[any.Method[FT], any.Expression[FT]], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val (startingCtxt, ifBranchExp) = Command.runGenerator[any.Method[FT], any.Expression[FT]](command.ifBranch, context) - val (elseIfCtxt, elseIfExprs) = command.elseIfBranches.foldLeft[(any.Method[FT], Seq[(any.Expression[FT], any.Expression[FT])])]((startingCtxt, Seq.empty)){ case ((ctxt, exprs), elseIfBranch) => - val (nextCtxt, elseIfExpr) = Command.runGenerator[any.Method[FT], any.Expression[FT]](elseIfBranch._2, ctxt) - (nextCtxt, exprs :+ (elseIfBranch._1, elseIfExpr)) + implicit val canIfThenElse: Understands[any.Method, IfThenElse[any.Expression, Generator[any.Method, any.Expression], Generator[any.Method, any.Expression], any.Expression]] = + new Understands[any.Method, IfThenElse[any.Expression, Generator[any.Method, any.Expression], Generator[any.Method, any.Expression], any.Expression]] { + override def perform(context: any.Method, command: IfThenElse[any.Expression, Generator[any.Method, any.Expression], Generator[any.Method, any.Expression], any.Expression]): (any.Method, any.Expression) = { + val (startingCtxt, ifBranchExp) = Command.runGenerator[any.Method, any.Expression](command.ifBranch, context) + val (elseIfCtxt, elseIfExprs) = command.elseIfBranches.foldLeft[(any.Method, Seq[(any.Expression, any.Expression)])]((startingCtxt, Seq.empty)) { case ((ctxt, exprs), elseIfBranch) => + val (nextCtxt, elseIfExpr) = Command.runGenerator[any.Method, any.Expression](elseIfBranch._2, ctxt) + (nextCtxt, exprs :+ (elseIfBranch._1, elseIfExpr)) + } + val (elseCtxt, elseExpr) = Command.runGenerator[any.Method, any.Expression](command.elseBranch, elseIfCtxt) + (elseCtxt, functionalControlFactory.funIfThenElse(command.condition, ifBranchExp, elseIfExprs, elseExpr)) } - val (elseCtxt, elseExpr) = Command.runGenerator[any.Method[FT], any.Expression[FT]](command.elseBranch, elseIfCtxt) - (elseCtxt, factory.funIfThenElse(command.condition, ifBranchExp, elseIfExprs, elseExpr)) } - } - implicit val canPatternMatch: Understands[any.Method[FT], control.PatternMatch[any.Method[FT], PatternContext, any.Expression[FT]]] = new Understands[any.Method[FT], control.PatternMatch[any.Method[FT], PatternContext, any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: control.PatternMatch[any.Method[FT], PatternContext, any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - val (finalCtxt, cases) = command.options.foldLeft((context, Seq.empty[(any.Expression[FT], any.Expression[FT])])) { - case ((ctxt, cases), option) => - val (patternCtxt, patternExp) = Command.runGenerator[PatternContext, any.Expression[FT]](option._1, factory.convert(ctxt).emptyPatternCtxt) - val patternVariables = patternCtxt.variables.distinct.map(name => factory.argumentExpression(name)) - val branchGen = option._2(patternVariables) - val (nextCtxt, branchExp) = Command.runGenerator(branchGen, ctxt) - (nextCtxt, cases :+ (patternExp, branchExp)) + implicit val canPatternMatch: Understands[any.Method, PatternMatch[any.Method, PatternContext, any.Expression]] = new Understands[any.Method, PatternMatch[any.Method, PatternContext, any.Expression]] { + override def perform(context: any.Method, command: PatternMatch[any.Method, PatternContext, any.Expression]): (any.Method, any.Expression) = { + val (finalCtxt, cases) = command.options.foldLeft((context, Seq.empty[(any.Expression, any.Expression)])) { + case ((ctxt, cases), option) => + val (patternCtxt, patternExp) = Command.runGenerator[PatternContext, any.Expression](option._1, factory.convert(ctxt).emptyPatternCtxt) + val patternVariables = patternCtxt.variables.distinct.map(name => factory.argumentExpression(name)) + val branchGen = option._2(patternVariables) + val (nextCtxt, branchExp) = Command.runGenerator(branchGen, ctxt) + (nextCtxt, cases :+ (patternExp, branchExp)) } - (finalCtxt, factory.patternMatch(command.onValue, cases)) + (finalCtxt, functionalControlFactory.patternMatch(command.onValue, cases)) + } } } - } - override val patternCapabilities: PatternCapabilities = new PatternCapabilities { - implicit val canPatternVariable: Understands[PatternContext, control.PatternVariable[any.Name[FT], any.Expression[FT]]] = new Understands[PatternContext, control.PatternVariable[any.Name[FT], any.Expression[FT]]] { - override def perform(context: PatternContext, command: control.PatternVariable[any.Name[FT], any.Expression[FT]]): (PatternContext, any.Expression[FT]) = { - (context.copy(context.variables :+ command.name), factory.patternVariable(command.name)) + override val patternCapabilities: PatternCapabilities = new PatternCapabilities { + implicit val canPatternVariable: Understands[PatternContext, PatternVariable[any.Name, any.Expression]] = new Understands[PatternContext, PatternVariable[any.Name, any.Expression]] { + override def perform(context: PatternContext, command: PatternVariable[any.Name, any.Expression]): (PatternContext, any.Expression) = { + (context.copy(context.variables :+ command.name), functionalControlFactory.patternVariable(command.name)) + } } - } - implicit def canReifyInPattern[T]: Understands[PatternContext, Reify[T, any.Expression[FT]]] = new Understands[PatternContext, Reify[T, any.Expression[FT]]] { - def perform(context: PatternContext, command: Reify[T, any.Expression[FT]]): (PatternContext, any.Expression[FT]) = { - (context, context.reify(command.tpe, command.value)) + implicit def canReifyInPattern[T]: Understands[PatternContext, Reify[T, any.Expression]] = new Understands[PatternContext, Reify[T, any.Expression]] { + def perform(context: PatternContext, command: Reify[T, any.Expression]): (PatternContext, any.Expression) = { + (context, context.reify(command.tpe, command.value)) + } } - } - - implicit val canApplyConstructorPattern: Understands[PatternContext, Apply[control.ConstructorPattern[any.Type[FT], any.Name[FT]], Generator[PatternContext, any.Expression[FT]], any.Expression[FT]]] = new Understands[PatternContext, Apply[control.ConstructorPattern[any.Type[FT], any.Name[FT]], Generator[PatternContext, any.Expression[FT]], any.Expression[FT]]] { - override def perform(context: PatternContext, command: Apply[control.ConstructorPattern[any.Type[FT], any.Name[FT]], Generator[PatternContext, any.Expression[FT]], any.Expression[FT]]): (PatternContext, any.Expression[FT]) = { - val (finalCtxt, argumentPatterns) = command.arguments.foldLeft((context, Seq.empty[any.Expression[FT]])) { case ((ctxt, args), argGen) => - val (nextCtxt, nextArg) = Command.runGenerator(argGen, ctxt) - (nextCtxt, args :+ nextArg) + + implicit val canApplyConstructorPattern: Understands[PatternContext, Apply[ConstructorPattern[any.Type, any.Name], Generator[PatternContext, any.Expression], any.Expression]] = new Understands[PatternContext, Apply[ConstructorPattern[any.Type, any.Name], Generator[PatternContext, any.Expression], any.Expression]] { + override def perform(context: PatternContext, command: Apply[ConstructorPattern[any.Type, any.Name], Generator[PatternContext, any.Expression], any.Expression]): (PatternContext, any.Expression) = { + val (finalCtxt, argumentPatterns) = command.arguments.foldLeft((context, Seq.empty[any.Expression])) { case ((ctxt, args), argGen) => + val (nextCtxt, nextArg) = Command.runGenerator(argGen, ctxt) + (nextCtxt, args :+ nextArg) + } + val patternApp = functionalControlFactory.constructorPattern(command.functional.tpe, command.functional.constructor, argumentPatterns) + (finalCtxt, patternApp) } - val patternApp = factory.constructorPattern(command.functional.tpe, command.functional.constructor, argumentPatterns) - (finalCtxt, patternApp) } } } + val functionalControlInMethods: FunctionalInMethods = new FunctionalInMethods {} } object Functional { - type WithBase[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Functional[FT, FactoryType] { val base: B } - def apply[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Functional[FT, FactoryType] { - val base: _base.type = _base - } + type WithBase[AST <: FunctionalControlAST, B <: AnyParadigm.WithAST[AST]] = Functional[AST, B] {} + + def apply[AST <: FunctionalControlAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Functional[AST, B](_base) {} } \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/FunctionalControlAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/FunctionalControlAST.scala new file mode 100644 index 00000000..e4853c59 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/FunctionalControlAST.scala @@ -0,0 +1,168 @@ +package org.combinators.ep.language.inbetween.functional.control + +import org.combinators.cogen.TypeRep +import org.combinators.ep.language.inbetween.any.AnyAST + +trait FunctionalControlAST extends AnyAST { + object funcontrol { + object anyOverrides { + trait FinalTypes extends any.FinalTypes { + type Method <: anyOverrides.Method + } + + trait Method extends any.Method { + def emptyPatternCtxt: PatternContext + } + } + + trait FinalTypes { + type Lambda <: funcontrol.Lambda + type DeclareFunVariable <: funcontrol.DeclareFunVariable + type FunIfThenElse <: funcontrol.IfThenElse + type PatternMatch <: funcontrol.PatternMatch + type PatternContext <: funcontrol.PatternContext + type PatternVariable <: funcontrol.PatternVariable + type ConstructorPattern <: funcontrol.ConstructorPattern + } + + trait Lambda extends any.Expression { + def getSelfLambda: functionalControlFinalTypes.Lambda + def variables: Seq[(any.Name, any.Type)] + def body: any.Expression + + def copy( + variables: Seq[(any.Name, any.Type)] = this.variables, + body: any.Expression = this.body + ): Lambda = functionalControlFactory.lambda(variables, body) + } + + trait DeclareFunVariable extends any.Expression { + def getSelfDeclareFunVariable: functionalControlFinalTypes.DeclareFunVariable + def name: any.Name + def tpe: any.Type + def isRecursive: Boolean + def initializer: any.Expression + def inExp: any.Expression + + def copy( + name: any.Name = name, + tpe: any.Type = tpe, + isRecursive: Boolean = isRecursive, + initializer: any.Expression = this.initializer, + inExp: any.Expression = this.inExp + ): DeclareFunVariable = functionalControlFactory.declareFunVariable(name, tpe, isRecursive = isRecursive, initializer, inExp) + } + + trait IfThenElse extends any.Expression { + def getSelfFunIfThenElse: functionalControlFinalTypes.FunIfThenElse + + def condition: any.Expression + def ifBranch: any.Expression + def elseIfBranches: Seq[(any.Expression, any.Expression)] + def elseBranch: any.Expression + + def copy( + condition: any.Expression = this.condition, + ifBranch: any.Expression = this.ifBranch, + elseIfBranches: Seq[(any.Expression, any.Expression)] = this.elseIfBranches, + elseBranch: any.Expression = this.elseBranch + ): IfThenElse = + functionalControlFactory.funIfThenElse(condition, ifBranch, elseIfBranches, elseBranch) + } + + trait PatternContext { + def getSelfPatternContext: functionalControlFinalTypes.PatternContext + + def variables: Seq[any.Name] + def reify[T](tpe: TypeRep.OfHostType[T], value: T): any.Expression + + def copy(variables: Seq[any.Name] = this.variables): PatternContext = functionalControlFactory.patternContext(variables) + } + + trait PatternVariable extends any.Expression { + def getSelfPatternVariable: functionalControlFinalTypes.PatternVariable + + def name: any.Name + + def copy(name: any.Name = this.name): PatternVariable = functionalControlFactory.patternVariable(name) + } + + trait ConstructorPattern extends any.Expression { + def getSelfConstructorPattern: functionalControlFinalTypes.ConstructorPattern + + def tpe: any.Type + def constructor: any.Name + def arguments: Seq[any.Expression] + + def copy( + tpe: any.Type = this.tpe, + constructor: any.Name = this.constructor, + arguments: Seq[any.Expression] = this.arguments + ): ConstructorPattern = functionalControlFactory.constructorPattern(tpe, constructor, arguments) + } + + trait PatternMatch extends any.Expression { + def getSelfPatternMatch: functionalControlFinalTypes.PatternMatch + + def onValue: any.Expression + def cases: Seq[(any.Expression, any.Expression)] + + def copy( + onValue: any.Expression = this.onValue, + cases: Seq[(any.Expression, any.Expression)] = this.cases + ): PatternMatch = + functionalControlFactory.patternMatch(onValue, cases) + } + + + + trait Factory { + def lambda( + variables: Seq[(any.Name, any.Type)], + body: any.Expression + ): Lambda + + def declareFunVariable( + name: any.Name, + tpe: any.Type, + isRecursive: Boolean, + initializer: any.Expression, + inExp: any.Expression + ): DeclareFunVariable + + def funIfThenElse( + condition: any.Expression, + ifBranch: any.Expression, + elseIfBranches: Seq[(any.Expression, any.Expression)], + elseBranch: any.Expression + ): IfThenElse + + def patternContext(variables: Seq[any.Name] = Seq.empty): PatternContext + + def patternVariable(name: any.Name): PatternVariable + + def constructorPattern( + tpe: any.Type, + constructor: any.Name, + arguments: Seq[any.Expression] + ): ConstructorPattern + + def patternMatch( + onValue: any.Expression, + cases: Seq[(any.Expression, any.Expression)] = Seq.empty + ): PatternMatch + + implicit def convert(other: Lambda): functionalControlFinalTypes.Lambda = other.getSelfLambda + implicit def convert(other: DeclareFunVariable): functionalControlFinalTypes.DeclareFunVariable = other.getSelfDeclareFunVariable + implicit def convert(other: IfThenElse): functionalControlFinalTypes.FunIfThenElse = other.getSelfFunIfThenElse + implicit def convert(other: PatternContext): functionalControlFinalTypes.PatternContext = other.getSelfPatternContext + implicit def convert(other: PatternVariable): functionalControlFinalTypes.PatternVariable = other.getSelfPatternVariable + implicit def convert(other: ConstructorPattern): functionalControlFinalTypes.ConstructorPattern = other.getSelfConstructorPattern + implicit def convert(other: PatternMatch): functionalControlFinalTypes.PatternMatch = other.getSelfPatternMatch + } + } + + val finalTypes: funcontrol.anyOverrides.FinalTypes + val functionalControlFinalTypes: funcontrol.FinalTypes + val functionalControlFactory: funcontrol.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/package.scala deleted file mode 100644 index b373a345..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/package.scala +++ /dev/null @@ -1,156 +0,0 @@ -package org.combinators.ep.language.inbetween.functional - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.language.inbetween.any - -package object control { - trait FinalTypes extends any.FinalTypes { - type Lambda <: Expression - type DeclareFunVariable <: Expression - type FunIfThenElse <: Expression - type PatternMatch <: Expression - type PatternContext - type PatternVariable <: Expression - type ConstructorPattern <: Expression - } - - trait Lambda[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfLambda: finalTypes.Lambda - def variables: Seq[(any.Name[FT], any.Type[FT])] - def body: any.Expression[FT] - - def copy( - variables: Seq[(any.Name[FT], any.Type[FT])] = this.variables, - body: any.Expression[FT] = this.body - ): Lambda[FT] = lambda(variables, body) - } - - trait DeclareFunVariable[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfDeclareFunVariable: finalTypes.DeclareFunVariable - def name: any.Name[FT] - def tpe: any.Type[FT] - def isRecursive: Boolean - def initializer: any.Expression[FT] - def inExp: any.Expression[FT] - - def copy( - name: any.Name[FT] = name, - tpe: any.Type[FT] = tpe, - isRecursive: Boolean = isRecursive, - initializer: any.Expression[FT] = this.initializer, - inExp: any.Expression[FT] = this.inExp - ): DeclareFunVariable[FT] = declareFunVariable(name, tpe, isRecursive = isRecursive, initializer, inExp) - } - - trait IfThenElse[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfFunIfThenElse: finalTypes.FunIfThenElse - - def condition: any.Expression[FT] - def ifBranch: any.Expression[FT] - def elseIfBranches: Seq[(any.Expression[FT], any.Expression[FT])] - def elseBranch: any.Expression[FT] - - def copy( - condition: any.Expression[FT] = this.condition, - ifBranch: any.Expression[FT] = this.ifBranch, - elseIfBranches: Seq[(any.Expression[FT], any.Expression[FT])] = this.elseIfBranches, - elseBranch: any.Expression[FT] = this.elseBranch - ): IfThenElse[FT] = - funIfThenElse(condition, ifBranch, elseIfBranches, elseBranch) - } - - trait PatternContext[FT <: FinalTypes] extends Factory[FT] { - def getSelfPatternContext: finalTypes.PatternContext - - def variables: Seq[any.Name[FT]] - def reify[T](tpe: TypeRep.OfHostType[T], value: T): any.Expression[FT] - - def copy(variables: Seq[any.Name[FT]] = this.variables): PatternContext[FT] = patternContext(variables) - } - - trait PatternVariable[FT <: FinalTypes] extends Factory[FT] with any.Expression[FT] { - def getSelfPatternVariable: finalTypes.PatternVariable - - def name: any.Name[FT] - - def copy(name: any.Name[FT] = this.name): PatternVariable[FT] = patternVariable(name) - } - - trait ConstructorPattern[FT <: FinalTypes] extends Factory[FT] with any.Expression[FT] { - def getSelfConstructorPattern: finalTypes.ConstructorPattern - - def tpe: any.Type[FT] - def constructor: any.Name[FT] - def arguments: Seq[any.Expression[FT]] - - def copy( - tpe: any.Type[FT] = this.tpe, - constructor: any.Name[FT] = this.constructor, - arguments: Seq[any.Expression[FT]] = this.arguments - ): ConstructorPattern[FT] = constructorPattern(tpe, constructor, arguments) - } - - trait PatternMatch[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfPatternMatch: finalTypes.PatternMatch - - def onValue: any.Expression[FT] - def cases: Seq[(any.Expression[FT], any.Expression[FT])] - - def copy( - onValue: any.Expression[FT] = this.onValue, - cases: Seq[(any.Expression[FT], any.Expression[FT])] = this.cases - ): PatternMatch[FT] = - patternMatch(onValue, cases) - } - - trait Method[FT <: FinalTypes] extends any.Method[FT] with Factory[FT] { - def emptyPatternCtxt: PatternContext[FT] - } - - trait Factory[FT <: FinalTypes] extends any.Factory[FT] { - def lambda( - variables: Seq[(any.Name[FT], any.Type[FT])], - body: any.Expression[FT] - ): Lambda[FT] - - def declareFunVariable( - name: any.Name[FT], - tpe: any.Type[FT], - isRecursive: Boolean, - initializer: any.Expression[FT], - inExp: any.Expression[FT] - ): DeclareFunVariable[FT] - - def funIfThenElse( - condition: any.Expression[FT], - ifBranch: any.Expression[FT], - elseIfBranches: Seq[(any.Expression[FT], any.Expression[FT])], - elseBranch: any.Expression[FT] - ): IfThenElse[FT] - - def patternContext(variables: Seq[any.Name[FT]] = Seq.empty): PatternContext[FT] - - def patternVariable(name: any.Name[FT]): PatternVariable[FT] - - def constructorPattern( - tpe: any.Type[FT], - constructor: any.Name[FT], - arguments: Seq[any.Expression[FT]] - ): ConstructorPattern[FT] - - def patternMatch( - onValue: any.Expression[FT], - cases: Seq[(any.Expression[FT], any.Expression[FT])] = Seq.empty - ): PatternMatch[FT] - - implicit def convert(other: Lambda[FT]): Lambda[FT] - implicit def convert(other: DeclareFunVariable[FT]): DeclareFunVariable[FT] - implicit def convert(other: IfThenElse[FT]): IfThenElse[FT] - implicit def convert(other: PatternContext[FT]): PatternContext[FT] - implicit def convert(other: PatternVariable[FT]): PatternVariable[FT] - implicit def convert(other: ConstructorPattern[FT]): ConstructorPattern[FT] - implicit def convert(other: PatternMatch[FT]): PatternMatch[FT] - implicit def convert(other: any.Method[FT]): Method[FT] - - } -} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/package.scala deleted file mode 100644 index fb183ced..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/package.scala +++ /dev/null @@ -1,213 +0,0 @@ -package org.combinators.ep.language.inbetween /*DI:LI:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.language.inbetween.any.{CompilationUnit, Project, TestSuite} - - -package object functional { - trait FinalTypes extends any.FinalTypes { - type AlgebraicDataType - type TypeConstructor - type TypeInstantiationExpression - type ADTReferenceType - } - - trait Project[FT <: FinalTypes] extends any.Project[FT] with Factory[FT] { - def adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty - def functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - - def addTypeLookupsForFunctions(lookups: TypeRep => Option[Generator[any.Method[FT], any.Type[FT]]]): any.Project[FT] = - copyAsFunctionalProject(functionTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.functionTypeLookupMap(tpeRep))) - - def addTypeLookupsForAlgebraicDataTypes(lookups: TypeRep => Option[Generator[functional.AlgebraicDataType[FT], any.Type[FT]]]): any.Project[FT] = - copyAsFunctionalProject(adtTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.adtTypeLookupMap(tpeRep))) - - override def copy( - compilationUnits: Set[any.CompilationUnit[FT]] - ): any.Project[FT] = copyAsFunctionalProject(compilationUnits) - - def copyAsFunctionalProject( - compilationUnits: Set[any.CompilationUnit[FT]] = this.compilationUnits, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = this.adtTypeLookupMap, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.functionTypeLookupMap, - ): Project[FT] = functionalProject(compilationUnits, adtTypeLookupMap, functionTypeLookupMap) - } - - trait CompilationUnit[FT <: FinalTypes] extends any.CompilationUnit[FT] with Factory[FT] { - def adts: Seq[functional.AlgebraicDataType[FT]] = Seq.empty - def functions: Seq[any.Method[FT]] = Seq.empty - - def adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty - def functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - - def resolveImport(tpe: any.Type[FT]): Seq[any.Import[FT]] - def resolveImport(exp: any.Expression[FT]): Seq[any.Import[FT]] - - def addTypeLookupsForFunctions(lookups: TypeRep => Option[Generator[any.Method[FT], any.Type[FT]]]): any.CompilationUnit[FT] = - copyAsFunctionalCompilationUnit(functionTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.functionTypeLookupMap(tpeRep))) - - def addTypeLookupsForAlgebraicDataTypes(lookups: TypeRep => Option[Generator[functional.AlgebraicDataType[FT], any.Type[FT]]]): any.CompilationUnit[FT] = - copyAsFunctionalCompilationUnit(adtTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.adtTypeLookupMap(tpeRep))) - - override def initializeInProject(project: any.Project[FT]): any.CompilationUnit[FT] = { - val withLookups = copyAsFunctionalCompilationUnit( - adtTypeLookupMap = project.adtTypeLookupMap, - functionTypeLookupMap = project.functionTypeLookupMap - ) - withLookups.copyAsFunctionalCompilationUnit( - tests = withLookups.tests.map(_.initializeInCompilationUnit(withLookups)) - ) - } - - override def copy( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): any.CompilationUnit[FT] = copyAsFunctionalCompilationUnit(name, imports, tests = tests) - - def copyAsFunctionalCompilationUnit( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - adtTypeLookupMap: TypeRep => Generator[AlgebraicDataType[FT], any.Type[FT]] = this.adtTypeLookupMap, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.functionTypeLookupMap, - adts: Seq[AlgebraicDataType[FT]] = this.adts, - functions: Seq[any.Method[FT]] = this.functions, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): CompilationUnit[FT] = funCompilationUnit(name, imports, adtTypeLookupMap, functionTypeLookupMap, adts, functions, tests) - } - - trait AlgebraicDataType[FT <: FinalTypes] extends Factory[FT] { - def getSelfAlgebraicDataType: finalTypes.AlgebraicDataType - - def name: any.Name[FT] - def imports: Seq[any.Import[FT]] = Seq.empty - def typeConstructors: Seq[TypeConstructor[FT]] = Seq.empty - - def typeLookupMap: TypeRep => Generator[AlgebraicDataType[FT], any.Type[FT]] = Map.empty - - def toTargetLanguageType(tpe: TypeRep): Generator[AlgebraicDataType[FT], any.Type[FT]] = typeLookupMap(tpe) - - def addTypeLookupsForAlgebraicDataTypes(lookups: TypeRep => Option[Generator[AlgebraicDataType[FT], any.Type[FT]]]): AlgebraicDataType[FT] = { - copy(typeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.typeLookupMap(tpeRep))) - } - - def findType(name: Seq[any.Name[FT]]): any.Type[FT] - - def resolveImport(tpe: any.Type[FT]): Seq[any.Import[FT]] - def resolveImport(exp: any.Expression[FT]): Seq[any.Import[FT]] - def getFreshName(basedOn: any.Name[FT]): any.Name[FT] - - def copy( - name: any.Name[FT] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - typeConstructors: Seq[TypeConstructor[FT]] = this.typeConstructors, - typeLookupMap: TypeRep => Generator[AlgebraicDataType[FT], any.Type[FT]] = this.typeLookupMap, - ): AlgebraicDataType[FT] = adt( - name = name, - imports = imports, - typeConstructors = typeConstructors, - typeLookupMap = typeLookupMap, - ) - } - - trait TypeConstructor[FT <: FinalTypes] extends Factory[FT]{ - def getSelfTypeConstructor: finalTypes.TypeConstructor - - def name: any.Name[FT] - def parameters: Seq[(any.Name[FT], any.Type[FT])] - - def copy( - name: any.Name[FT] = this.name, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters - ): TypeConstructor[FT] = typeConstructor(name, parameters) - } - - trait TypeInstantiationExpression[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfTypeInstantiationExpression: finalTypes.TypeInstantiationExpression - - def tpe: any.Type[FT] - def constructorName: Seq[any.Name[FT]] - def constructorArguments: Seq[any.Expression[FT]] - - def copy( - tpe: any.Type[FT] = this.tpe, - constructorName: Seq[any.Name[FT]] = this.constructorName, - constructorArguments: Seq[any.Expression[FT]] = this.constructorArguments - ): TypeInstantiationExpression[FT] = typeInstantiationExpression(tpe, constructorName, constructorArguments) - } - - trait Method[FT <: FinalTypes] extends any.Method[FT] { - def resolveImport(exp: any.Expression[FT]): Seq[any.Import[FT]] - - def findMethod(name: Seq[any.Name[FT]]): any.Expression[FT] - def findType(name: Seq[any.Name[FT]]): any.Type[FT] - } - - trait ADTReferenceType[FT <: FinalTypes] extends any.Type[FT] with Factory[FT] { - def getSelfADTReferenceType: finalTypes.ADTReferenceType - - def qualifiedTypeName: Seq[any.Name[FT]] - - def copy( - qualifiedTypeName: Seq[any.Name[FT]] = this.qualifiedTypeName - ): ADTReferenceType[FT] = adtReferenceType(qualifiedTypeName:_*) - } - - trait Factory[FT <: FinalTypes] extends any.Factory[FT] { - - override def project(compilationUnits: Set[any.CompilationUnit[FT]]): any.Project[FT] = - functionalProject(compilationUnits = compilationUnits, adtTypeLookupMap=Map.empty, functionTypeLookupMap=Map.empty) - - - def functionalProject( - compilationUnits: Set[any.CompilationUnit[FT]] = Set.empty, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - ): any.Project[FT] - - - override def compilationUnit(name: Seq[any.Name[FT]], imports: Seq[any.Import[FT]], tests: Seq[any.TestSuite[FT]]): any.CompilationUnit[FT] = - funCompilationUnit(name, imports, adtTypeLookupMap=Map.empty, functionTypeLookupMap=Map.empty, adts=Seq.empty, functions=Seq.empty, tests = tests) - - def funCompilationUnit( - name: Seq[any.Name[FT]], - imports: Seq[any.Import[FT]], - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - adts: Seq[functional.AlgebraicDataType[FT]] = Seq.empty, - functions: Seq[any.Method[FT]] = Seq.empty, - tests: Seq[any.TestSuite[FT]] = Seq.empty, - ): CompilationUnit[FT] - - def adt( - name: any.Name[FT], - imports: Seq[any.Import[FT]] = Seq.empty, - typeConstructors: Seq[TypeConstructor[FT]] = Seq.empty, - typeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - ): AlgebraicDataType[FT] - - def typeConstructor( - name: any.Name[FT], - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty - ): TypeConstructor[FT] - - def typeInstantiationExpression( - tpe: any.Type[FT], - constructorName: Seq[any.Name[FT]], - constructorArguments: Seq[any.Expression[FT]] = Seq.empty, - ): TypeInstantiationExpression[FT] - - def adtReferenceType(qualifiedTypeName: any.Name[FT]*): ADTReferenceType[FT] - - override implicit def convert(other: any.Project[FT]): Project[FT] - override implicit def convert(other: any.CompilationUnit[FT]): CompilationUnit[FT] - override implicit def convert(other: any.Method[FT]): Method[FT] - - implicit def convert(other: functional.AlgebraicDataType[FT]): AlgebraicDataType[FT] - implicit def convert(other: functional.TypeConstructor[FT]): TypeConstructor[FT] - implicit def convert(other: functional.TypeInstantiationExpression[FT]): TypeInstantiationExpression[FT] - implicit def convert(other: functional.ADTReferenceType[FT]): ADTReferenceType[FT] - } -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/Imperative.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/Imperative.scala index ccdbdc4e..9e7e493f 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/Imperative.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/Imperative.scala @@ -1,93 +1,94 @@ package org.combinators.ep.language.inbetween.imperative /*DI:LI:AI*/ -import org.combinators.ep.generator -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.control -import org.combinators.ep.generator.{Command, FileWithPath, Understands, paradigm} -import org.combinators.ep.generator.paradigm.control.{Return, Imperative => Imp, DeclareVariable => DV} -import org.combinators.ep.language.inbetween.any +import org.combinators.cogen.paradigm.{IfThenElse, control} +import org.combinators.cogen.paradigm.control.{AssignVariable, DeclareVariable, LiftExpression, Return, While} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, FileWithPath, Understands, paradigm} +import org.combinators.cogen.paradigm.control.{Return, DeclareVariable as DV, Imperative as Imp} import org.combinators.ep.language.inbetween.any.AnyParadigm // Requires "recursive solution" to the EP, where Ctxt has a producer method and so this needs an EP solution, while // talking about something which doesn't need to have one.. -trait Imperative[FT <: FinalTypes, FactoryType <: Factory[FT]] extends Imp[any.Method[FT]] { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.factory +trait Imperative[AST <: ImperativeAST, B](val _base: AnyParadigm.WithAST[AST] & B) { + trait ImperativeInMethods extends control.Imperative[_base.ast.any.Method] { + override val base: _base.type = _base + import base.ast.any + import base.ast.factory + import base.ast.imperativeFactory - type Ctxt = any.Method[FT] + type Ctxt = any.Method - def pushToContext(context: Ctxt, stmt: any.Statement[FT]): Ctxt = { - context.copy(statements = context.statements :+ stmt) - } - - val imperativeCapabilities: ImperativeCapabilities = new ImperativeCapabilities { - implicit val canDeclareVariable: Understands[Ctxt, DV[any.Name[FT], any.Type[FT], Option[any.Expression[FT]], any.Expression[FT]]] = new Understands[Ctxt, DV[any.Name[FT], any.Type[FT], Option[any.Expression[FT]], any.Expression[FT]]] { - def perform(context: Ctxt, command: DV[any.Name[FT], any.Type[FT], Option[any.Expression[FT]], any.Expression[FT]]): (Ctxt, any.Expression[FT]) = { - (pushToContext(context, factory.declareVariable(command.name, command.tpe, command.initialization)), factory.variableReferenceExpression(command.name)) - } + def pushToContext(context: Ctxt, stmt: any.Statement): Ctxt = { + context.copy(statements = context.statements :+ stmt) } - implicit val canAssignVariable: Understands[Ctxt, control.AssignVariable[any.Expression[FT], any.Statement[FT]]] = - new Understands[Ctxt, control.AssignVariable[any.Expression[FT], any.Statement[FT]]] { - override def perform(context: Ctxt, command: control.AssignVariable[any.Expression[FT], any.Statement[FT]]): (Ctxt, any.Statement[FT]) = { - val assignStmt = factory.assignVariable(command.variable, command.value) - (context, assignStmt) - } - } - implicit val canLiftExpression: Understands[Ctxt, control.LiftExpression[any.Expression[FT], any.Statement[FT]]] = - new Understands[Ctxt, control.LiftExpression[any.Expression[FT], any.Statement[FT]]] { - override def perform(context: Ctxt, command: control.LiftExpression[any.Expression[FT], any.Statement[FT]]): (Ctxt, any.Statement[FT]) = { - val liftStmt = factory.liftExpression(command.expr) - (context, liftStmt) + val imperativeCapabilities: ImperativeCapabilities = new ImperativeCapabilities { + implicit val canDeclareVariable: Understands[Ctxt, DeclareVariable[any.Name, any.Type, Option[any.Expression], any.Expression]] = new Understands[Ctxt, DeclareVariable[any.Name, any.Type, Option[any.Expression], any.Expression]] { + def perform(context: Ctxt, command: DeclareVariable[any.Name, any.Type, Option[any.Expression], any.Expression]): (Ctxt, any.Expression) = { + (pushToContext(context, imperativeFactory.declareVariable(command.name, command.tpe, command.initialization)), imperativeFactory.variableReferenceExpression(command.name)) } } - implicit val canIfThenElse: Understands[Ctxt, paradigm.IfThenElse[any.Expression[FT], Generator[Ctxt, Unit], Option[Generator[Ctxt, Unit]], any.Statement[FT]]] = - new Understands[Ctxt, paradigm.IfThenElse[any.Expression[FT], Generator[Ctxt, Unit], Option[Generator[Ctxt, Unit]], any.Statement[FT]]] { - /** Returns the updated context and the result of the command. */ - override def perform(context: Ctxt, command: paradigm.IfThenElse[any.Expression[FT], Generator[Ctxt, Unit], Option[Generator[Ctxt, Unit]], any.Statement[FT]]): (Ctxt, any.Statement[FT]) = { - def contextWithoutMethodBody(context: Ctxt) = - context.copy(statements = Seq.empty) - val (ifCtxt, _) = Command.runGenerator(command.ifBranch, contextWithoutMethodBody(context)) - val (elseIfCtxt, elseIfBranches) = command.elseIfBranches.foldLeft((ifCtxt, Seq.empty[(any.Expression[FT], Seq[any.Statement[FT]])])) { case ((lastCtxt, elseIfBranches), (condition, elseIfBranch)) => - val (elseIfCtxt, _) = Command.runGenerator(elseIfBranch, contextWithoutMethodBody(lastCtxt)) - (elseIfCtxt, elseIfBranches :+ (condition, elseIfCtxt.statements)) + implicit val canAssignVariable: Understands[Ctxt, AssignVariable[any.Expression, any.Statement]] = + new Understands[Ctxt, AssignVariable[any.Expression, any.Statement]] { + override def perform(context: Ctxt, command: AssignVariable[any.Expression, any.Statement]): (Ctxt, any.Statement) = { + val assignStmt = imperativeFactory.assignVariable(command.variable, command.value) + (context, assignStmt) } - val elseCtxt = - command.elseBranch.map(elseBranch => - Command.runGenerator(elseBranch, contextWithoutMethodBody(elseIfCtxt))._1 - ) - val elseBranch = elseCtxt.map(_.statements).getOrElse(Seq.empty) - val lastCtxt = elseCtxt.getOrElse(elseIfCtxt) + } + implicit val canLiftExpression: Understands[Ctxt, LiftExpression[any.Expression, any.Statement]] = + new Understands[Ctxt, LiftExpression[any.Expression, any.Statement]] { + override def perform(context: Ctxt, command: LiftExpression[any.Expression, any.Statement]): (Ctxt, any.Statement) = { + val liftStmt = imperativeFactory.liftExpression(command.expr) + (context, liftStmt) + } + } + implicit val canIfThenElse: Understands[Ctxt, IfThenElse[any.Expression, Generator[Ctxt, Unit], Option[Generator[Ctxt, Unit]], any.Statement]] = + new Understands[Ctxt, IfThenElse[any.Expression, Generator[Ctxt, Unit], Option[Generator[Ctxt, Unit]], any.Statement]] { + /** Returns the updated context and the result of the command. */ + override def perform(context: Ctxt, command: IfThenElse[any.Expression, Generator[Ctxt, Unit], Option[Generator[Ctxt, Unit]], any.Statement]): (Ctxt, any.Statement) = { + def contextWithoutMethodBody(context: Ctxt) = + context.copy(statements = Seq.empty) - val ifThenElseStmt = factory.ifThenElse(command.condition, ifCtxt.statements, elseIfBranches, elseBranch) - (lastCtxt.copy(statements = context.statements), ifThenElseStmt) + val (ifCtxt, _) = Command.runGenerator(command.ifBranch, contextWithoutMethodBody(context)) + val (elseIfCtxt, elseIfBranches) = command.elseIfBranches.foldLeft((ifCtxt, Seq.empty[(any.Expression, Seq[any.Statement])])) { case ((lastCtxt, elseIfBranches), (condition, elseIfBranch)) => + val (elseIfCtxt, _) = Command.runGenerator(elseIfBranch, contextWithoutMethodBody(lastCtxt)) + (elseIfCtxt, elseIfBranches :+ (condition, elseIfCtxt.statements)) + } + val elseCtxt = + command.elseBranch.map(elseBranch => + Command.runGenerator(elseBranch, contextWithoutMethodBody(elseIfCtxt))._1 + ) + val elseBranch = elseCtxt.map(_.statements).getOrElse(Seq.empty) + val lastCtxt = elseCtxt.getOrElse(elseIfCtxt) + + val ifThenElseStmt = imperativeFactory.ifThenElse(command.condition, ifCtxt.statements, elseIfBranches, elseBranch) + (lastCtxt.copy(statements = context.statements), ifThenElseStmt) + } } - } - implicit val canWhile: Understands[Ctxt, control.While[Ctxt, any.Expression[FT], any.Statement[FT]]] = new Understands[Ctxt, control.While[Ctxt, any.Expression[FT], any.Statement[FT]]] { - def perform(context: Ctxt, command: control.While[Ctxt, any.Expression[FT], any.Statement[FT]]): (Ctxt, any.Statement[FT]) = { - def contextWithoutMethodBody(context: Ctxt) = - context.copy(statements = Seq.empty) + implicit val canWhile: Understands[Ctxt, While[Ctxt, any.Expression, any.Statement]] = new Understands[Ctxt, While[Ctxt, any.Expression, any.Statement]] { + def perform(context: Ctxt, command: While[Ctxt, any.Expression, any.Statement]): (Ctxt, any.Statement) = { + def contextWithoutMethodBody(context: Ctxt) = + context.copy(statements = Seq.empty) - val (blockCtxt, _) = Command.runGenerator(command.block, contextWithoutMethodBody(context)) - val whileStmt = factory.whileLoop(command.condition, blockCtxt.statements) - (blockCtxt.copy(statements = context.statements), whileStmt) + val (blockCtxt, _) = Command.runGenerator(command.block, contextWithoutMethodBody(context)) + val whileStmt = imperativeFactory.whileLoop(command.condition, blockCtxt.statements) + (blockCtxt.copy(statements = context.statements), whileStmt) + } } - } - implicit val canReturn: Understands[Ctxt, Return[any.Expression[FT], any.Statement[FT]]] = new Understands[Ctxt, Return[any.Expression[FT], any.Statement[FT]]] { - def perform(context: Ctxt, command: Return[any.Expression[FT], any.Statement[FT]]): (Ctxt, any.Statement[FT]) = { - val returnStmt = factory.returnExpression(command.exp) - (context, returnStmt) + implicit val canReturn: Understands[Ctxt, Return[any.Expression, any.Statement]] = new Understands[Ctxt, Return[any.Expression, any.Statement]] { + def perform(context: Ctxt, command: Return[any.Expression, any.Statement]): (Ctxt, any.Statement) = { + val returnStmt = factory.returnExpression(command.exp) + (context, returnStmt) + } } } } - + val imperativeInMethods: ImperativeInMethods = new ImperativeInMethods {} } object Imperative { - type WithBase[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = Imperative[FT, FactoryType] { val base: B } - def apply[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new Imperative[FT, FactoryType] { - val base: _base.type = _base - } + type WithBase[AST <: ImperativeAST, B <: AnyParadigm.WithAST[AST]] = Imperative[AST, B] {} + def apply[AST <: ImperativeAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new Imperative[AST, B](_base) {} } \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/ImperativeAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/ImperativeAST.scala new file mode 100644 index 00000000..e9a45434 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/ImperativeAST.scala @@ -0,0 +1,108 @@ +package org.combinators.ep.language.inbetween.imperative + +import org.combinators.ep.language.inbetween.any.AnyAST + +trait ImperativeAST extends AnyAST { + object imperative { + trait FinalTypes { + type DeclareVariable <: imperative.DeclareVariable + type AssignVariable <: imperative.AssignVariable + type IfThenElse <: imperative.IfThenElse + type While <: imperative.While + type VariableReferenceExpression <: imperative.VariableReferenceExpression + } + + trait DeclareVariable extends any.Statement { + def getSelfDeclareVariable: imperativeFinalTypes.DeclareVariable + def name: any.Name + def tpe: any.Type + def initializer: Option[any.Expression] + + def copy(name: any.Name = name, tpe: any.Type = tpe, initializer: Option[any.Expression] = initializer): DeclareVariable = + imperativeFactory.declareVariable(name, tpe, initializer) + } + + trait VariableReferenceExpression extends any.Expression { + def getSelfVariableReferenceExpression: imperativeFinalTypes.VariableReferenceExpression + def name: any.Name + + def copy(name: any.Name = name): VariableReferenceExpression = + imperativeFactory.variableReferenceExpression(name) + } + + trait AssignVariable extends any.Statement { + def getSelfAssignVariable: imperativeFinalTypes.AssignVariable + def variable: any.Expression + def assignmentExpression: any.Expression + + def copy(variable: any.Expression = variable, assignmentExpression: any.Expression = assignmentExpression): AssignVariable = + imperativeFactory.assignVariable(variable, assignmentExpression) + } + + trait LiftExpression extends any.Statement { + def expression: any.Expression + + def copy(expression: any.Expression = expression): LiftExpression = imperativeFactory.liftExpression(expression) + } + + trait IfThenElse extends any.Statement { + def getSelfIfThenElse: imperativeFinalTypes.IfThenElse + + def condition: any.Expression + def ifBranch: Seq[any.Statement] + def elseIfBranches: Seq[(any.Expression, Seq[any.Statement])] + def elseBranch: Seq[any.Statement] + + def copy( + condition: any.Expression = condition, + ifBranch: Seq[any.Statement] = ifBranch, + elseIfBranches: Seq[(any.Expression, Seq[any.Statement])] = elseIfBranches, + elseBranch: Seq[any.Statement] = elseBranch + ): IfThenElse = + imperativeFactory.ifThenElse(condition, ifBranch, elseIfBranches, elseBranch) + } + + trait While extends any.Statement { + def getSelfWhile: imperativeFinalTypes.While + + def condition: any.Expression + def body: Seq[any.Statement] + + def copy( + condition: any.Expression = condition, + body: Seq[any.Statement] = body + ): While = imperativeFactory.whileLoop(condition, body) + } + + + trait Factory { + def declareVariable( + name: any.Name, + tpe: any.Type, + initializer: Option[any.Expression] + ): DeclareVariable + + def variableReferenceExpression(name: any.Name): VariableReferenceExpression + def assignVariable(variable: any.Expression, expression: any.Expression): AssignVariable + def liftExpression(expression: any.Expression): LiftExpression + + def ifThenElse( + condition: any.Expression, + ifBranch: Seq[any.Statement], + elseIfBranches: Seq[(any.Expression, Seq[any.Statement])], + elseBranch: Seq[any.Statement] + ): IfThenElse + def whileLoop(condition: any.Expression, body: Seq[any.Statement]): While + + + implicit def convert(other: DeclareVariable): imperativeFinalTypes.DeclareVariable = other.getSelfDeclareVariable + implicit def convert(other: AssignVariable): imperativeFinalTypes.AssignVariable = other.getSelfAssignVariable + implicit def convert(other: IfThenElse): imperativeFinalTypes.IfThenElse = other.getSelfIfThenElse + implicit def convert(other: While): imperativeFinalTypes.While = other.getSelfWhile + implicit def convert(other: VariableReferenceExpression): imperativeFinalTypes.VariableReferenceExpression = other.getSelfVariableReferenceExpression + } + } + + val imperativeFinalTypes: imperative.FinalTypes + val imperativeFactory: imperative.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/package.scala deleted file mode 100644 index 6025169e..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/package.scala +++ /dev/null @@ -1,101 +0,0 @@ -package org.combinators.ep.language.inbetween /*DI:LI:AI*/ - -import scala.meta.Term.If - -package object imperative { - trait FinalTypes extends any.FinalTypes { - type DeclareVariable <: Statement - type AssignVariable <: Statement - type IfThenElse <: Statement - type While <: Statement - type VariableReferenceExpression <: Expression - } - - trait DeclareVariable[FT <: FinalTypes] extends any.Statement[FT] with Factory[FT] { - def getSelfDeclareVariable: finalTypes.DeclareVariable - def name: any.Name[FT] - def tpe: any.Type[FT] - def initializer: Option[any.Expression[FT]] - - def copy(name: any.Name[FT] = name, tpe: any.Type[FT] = tpe, initializer: Option[any.Expression[FT]] = initializer): DeclareVariable[FT] = - declareVariable(name, tpe, initializer) - } - - trait VariableReferenceExpression[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfVariableReferenceExpression: finalTypes.VariableReferenceExpression - def name: any.Name[FT] - - def copy(name: any.Name[FT] = name): VariableReferenceExpression[FT] = - variableReferenceExpression(name) - } - - trait AssignVariable[FT <: FinalTypes] extends any.Statement[FT] with Factory[FT] { - def getSelfAssignVariable: finalTypes.AssignVariable - def variable: any.Expression[FT] - def assignmentExpression: any.Expression[FT] - - def copy(variable: any.Expression[FT] = variable, assignmentExpression: any.Expression[FT] = assignmentExpression): AssignVariable[FT] = - assignVariable(variable, assignmentExpression) - } - - trait LiftExpression[FT <: FinalTypes] extends any.Statement[FT] with Factory[FT] { - def expression: any.Expression[FT] - - def copy(expression: any.Expression[FT] = expression): LiftExpression[FT] = liftExpression(expression) - } - - trait IfThenElse[FT <: FinalTypes] extends any.Statement[FT] with Factory[FT] { - def getSelfIfThenElse: finalTypes.IfThenElse - - def condition: any.Expression[FT] - def ifBranch: Seq[any.Statement[FT]] - def elseIfBranches: Seq[(any.Expression[FT], Seq[any.Statement[FT]])] - def elseBranch: Seq[any.Statement[FT]] - - def copy( - condition: any.Expression[FT] = condition, - ifBranch: Seq[any.Statement[FT]] = ifBranch, - elseIfBranches: Seq[(any.Expression[FT], Seq[any.Statement[FT]])] = elseIfBranches, - elseBranch: Seq[any.Statement[FT]] = elseBranch - ): IfThenElse[FT] = - ifThenElse(condition, ifBranch, elseIfBranches, elseBranch) - } - - trait While[FT <: FinalTypes] extends any.Statement[FT] with Factory[FT] { - def getSelfWhile: finalTypes.While - - def condition: any.Expression[FT] - def body: Seq[any.Statement[FT]] - - def copy( - condition: any.Expression[FT] = condition, - body: Seq[any.Statement[FT]] = body - ): While[FT] = whileLoop(condition, body) - } - - - trait Factory[FT <: FinalTypes] extends any.Factory[FT] { - def declareVariable( - name: any.Name[FT], - tpe: any.Type[FT], - initializer: Option[any.Expression[FT]]): DeclareVariable[FT] - - def variableReferenceExpression(name: any.Name[FT]): VariableReferenceExpression[FT] - def assignVariable(variable: any.Expression[FT], expression: any.Expression[FT]): AssignVariable[FT] - def liftExpression(expression: any.Expression[FT]): LiftExpression[FT] - - def ifThenElse( - condition: any.Expression[FT], - ifBranch: Seq[any.Statement[FT]], - elseIfBranches: Seq[(any.Expression[FT], Seq[any.Statement[FT]])], - elseBranch: Seq[any.Statement[FT]]): IfThenElse[FT] - def whileLoop(condition: any.Expression[FT], body: Seq[any.Statement[FT]]): While[FT] - - - implicit def convert(decl: DeclareVariable[FT]): DeclareVariable[FT] - implicit def convert(assignVariable: AssignVariable[FT]): AssignVariable[FT] - implicit def convert(ifThenElse: IfThenElse[FT]): IfThenElse[FT] - implicit def convert(whileLoop: While[FT]): While[FT] - implicit def convert(varRef: VariableReferenceExpression[FT]): VariableReferenceExpression[FT] - } -} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOAST.scala new file mode 100644 index 00000000..c87b6299 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOAST.scala @@ -0,0 +1,534 @@ +package org.combinators.ep.language.inbetween.oo + +import org.combinators.cogen.{FileWithPath, TypeRep} +import org.combinators.cogen.Command.Generator +import org.combinators.ep.language.inbetween.any.AnyAST + +trait OOAST extends AnyAST { + + object oo { + object anyOverrides { + trait FinalTypes extends any.FinalTypes { + type Method <: anyOverrides.Method + type Expression <: anyOverrides.Expression + type TestSuite <: anyOverrides.TestSuite + type CompilationUnit <: anyOverrides.CompilationUnit + type Project <: anyOverrides.Project + } + + trait Project extends any.Project { + def methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + def constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty + def classTypeLookupMap: TypeRep => Generator[Class, any.Type] = Map.empty + + override def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method, any.Type]]): any.Project = + copyAsProjectWithTypeLookups(methodTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.methodTypeLookupMap(tpeRep))) + + def addTypeLookupsForConstructors(lookups: TypeRep => Option[Generator[oo.Constructor, any.Type]]): any.Project = + copyAsProjectWithTypeLookups(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) + + def addTypeLookupsForClasses(lookups: TypeRep => Option[Generator[oo.Class, any.Type]]): any.Project = + copyAsProjectWithTypeLookups(classTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.classTypeLookupMap(tpeRep))) + + override def copy( + compilationUnits: Set[any.CompilationUnit], + customFiles: Seq[FileWithPath] + ): any.Project = copyAsProjectWithTypeLookups(compilationUnits, customFiles) + + def copyAsProjectWithTypeLookups( + compilationUnits: Set[any.CompilationUnit] = this.compilationUnits, + customFiles: Seq[FileWithPath] = this.customFiles, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = this.constructorTypeLookupMap, + classTypeLookupMap: TypeRep => Generator[Class, any.Type] = this.classTypeLookupMap + ): Project = ooFactory.ooProject(compilationUnits, customFiles, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap) + } + + trait CompilationUnit extends any.CompilationUnit { + def classes: Seq[Class] = Seq.empty + def methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + def constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty + def classTypeLookupMap: TypeRep => Generator[Class, any.Type] = Map.empty + + def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method, any.Type]]): any.CompilationUnit = + copyAsCompilationUnitWithClasses(methodTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.methodTypeLookupMap(tpeRep))) + + def addTypeLookupsForConstructors(lookups: TypeRep => Option[Generator[oo.Constructor, any.Type]]): any.CompilationUnit = + copyAsCompilationUnitWithClasses(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) + + def addTypeLookupsForClasses(lookups: TypeRep => Option[Generator[oo.Class, any.Type]]): any.CompilationUnit = + copyAsCompilationUnitWithClasses(classTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.classTypeLookupMap(tpeRep))) + + override def initializeInProject(project: any.Project): any.CompilationUnit = { + import factory.convert + val withLookups = copyAsCompilationUnitWithClasses(classTypeLookupMap = project.classTypeLookupMap, + constructorTypeLookupMap = project.constructorTypeLookupMap, + methodTypeLookupMap = project.methodTypeLookupMap + ) + withLookups.copyAsCompilationUnitWithClasses( + tests = withLookups.tests.map(_.initializeInCompilationUnit(withLookups)) + ) + } + + override def copy( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + tests: Seq[any.TestSuite] = this.tests, + ): any.CompilationUnit = copyAsCompilationUnitWithClasses(name, imports, tests = tests) + + def copyAsCompilationUnitWithClasses( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = this.constructorTypeLookupMap, + classTypeLookupMap: TypeRep => Generator[Class, any.Type] = this.classTypeLookupMap, + classes: Seq[Class] = this.classes, + tests: Seq[any.TestSuite] = this.tests, + ): CompilationUnit = ooFactory.ooCompilationUnit(name, imports, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap, classes, tests) + } + + trait TestSuite extends any.TestSuite { + def underlyingClass: Class + def testMarkers: Seq[Boolean] + + override def name: any.Name = underlyingClass.name + override def tests: Seq[any.Method] = underlyingClass.methods.zip(testMarkers).filter { case (m, isTest) => isTest }.map(_._1) + override def methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = underlyingClass.methodTypeLookupMap + + override def initializeInCompilationUnit(compilationUnit: any.CompilationUnit): any.TestSuite = { + import factory.convert + copyAsClassBasedTestSuite( + underlyingClass = underlyingClass.copy( + constructorTypeLookupMap = compilationUnit.constructorTypeLookupMap, + methodTypeLookupMap = compilationUnit.methodTypeLookupMap, + typeLookupMap = compilationUnit.classTypeLookupMap, + ), + testMarkers + ) + } + + override def copy( + name: any.Name = this.name, + tests: Seq[any.Method] = this.tests, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + ): any.TestSuite = { + val helpers = underlyingClass.methods.zip(this.testMarkers).filter { case (m, isTest) => !isTest }.map(_._1) + val testMarkers = Seq.fill(helpers.size)(false) ++ Seq.fill(tests.size)(true) + + copyAsClassBasedTestSuite( + underlyingClass = this.underlyingClass.copy( + name = name, + methods = helpers ++ tests, + methodTypeLookupMap = methodTypeLookupMap + ), + testMarkers + ) + } + + def copyAsClassBasedTestSuite( + underlyingClass: Class = this.underlyingClass, + testMarkers: Seq[Boolean] = this.testMarkers + ): any.TestSuite = ooFactory.classBasedTestSuite(underlyingClass, testMarkers) + + } + + trait Method extends any.Method { + def isAbstract: Boolean = false + def isStatic: Boolean = false + def isPublic: Boolean = false + def isOverride: Boolean = false + + def findClass(qualifiedName: any.Name*): any.Type + + def addTestExpressions(exprs: Seq[any.Expression]): any.Method + + override def copy( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap + ): any.Method = ooFactory.clsMethod(name, imports, statements, returnType, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) + + def copyAsClsMethod( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isStatic: Boolean = this.isStatic, + isPublic: Boolean = this.isPublic, + isOverride: Boolean = this.isOverride, + ): Method = ooFactory.clsMethod(name, imports, statements, returnType, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) + } + + trait Expression extends any.Expression { + + } + + trait Factory extends any.Factory { + import ooFactory.* + + override def project(compilationUnits: Set[any.CompilationUnit], customFiles: Seq[FileWithPath]): any.Project = + ooProject(compilationUnits = compilationUnits, customFiles = customFiles, methodTypeLookupMap = Map.empty, constructorTypeLookupMap = Map.empty, classTypeLookupMap = Map.empty) + + override def compilationUnit(name: Seq[any.Name], imports: Seq[any.Import], tests: Seq[any.TestSuite]): any.CompilationUnit = + ooCompilationUnit(name, imports, methodTypeLookupMap = Map.empty, constructorTypeLookupMap = Map.empty, classTypeLookupMap = Map.empty, classes = Seq.empty, tests = tests) + + override def method( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + ): any.Method = clsMethod(name, imports, statements, returnType, parameters, typeLookupMap) + + override def testSuite(name: any.Name, tests: Seq[any.Method], methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty): any.TestSuite = + classBasedTestSuite(cls(name = name, methods = tests, methodTypeLookupMap = methodTypeLookupMap), Seq.fill(tests.size)(true)) + } + + } + + trait FinalTypes { + type Class <: oo.Class + type Constructor <: oo.Constructor + type Field <: oo.Field + type MemberAccessExpression <: oo.MemberAccessExpression + type SelfReferenceExpression <: oo.SelfReferenceExpression + type ObjectInstantiationExpression <: oo.ObjectInstantiationExpression + type CastExpression <: oo.CastExpression + type InstanceOfExpression <: oo.InstanceOfExpression + type SuperReferenceExpression <: oo.SuperReferenceExpression + type ClassReferenceType <: oo.ClassReferenceType + } + + trait Class { + def getSelfClass: ooFinalTypes.Class + + def name: any.Name + def imports: Seq[any.Import] = Seq.empty + def parents: Seq[any.Type] = Seq.empty + def implemented: Seq[any.Type] = Seq.empty + def fields: Seq[Field] = Seq.empty + def methods: Seq[any.Method] = Seq.empty + def constructors: Seq[Constructor] = Seq.empty + def methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + def constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty + def typeLookupMap: TypeRep => Generator[Class, any.Type] = Map.empty + def isAbstract: Boolean = false + def isInterface: Boolean = false + def isStatic: Boolean = false + + def toTargetLanguageType(tpe: TypeRep): Generator[Class, any.Type] = typeLookupMap(tpe) + + def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method, any.Type]]): oo.Class = + copy(methodTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.methodTypeLookupMap(tpeRep))) + + def addTypeLookupsForConstructors(lookups: TypeRep => Option[Generator[oo.Constructor, any.Type]]): oo.Class = + copy(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) + + def addTypeLookupsForClasses(lookups: TypeRep => Option[Generator[Class, any.Type]]): oo.Class = { + copy(typeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.typeLookupMap(tpeRep))) + } + + def addParent(parent: any.Type): Class = + copy(parents = (this.parents :+ parent).distinct) + + def addImplemented(impl: any.Type): Class = + copy(implemented = (this.implemented :+ impl).distinct) + + def addField(field: Field): Class = + copy(fields = this.fields :+ field) // TODO: make distinct by name + + def getField(name: any.Name): any.Expression = + ooFactory.memberAccessExpression(ooFactory.selfReferenceExpression, name) + + def addMethod(method: any.Method): Class = + copy(methods = this.methods :+ method) + + def addConstructor(constructor: Constructor): Class = + copy(constructors = this.constructors :+ constructor) + + def resolveImport(tpe: any.Type): Seq[any.Import] + def findClass(qualifiedName: any.Name*): any.Type + def getFreshName(basedOn: any.Name): any.Name + + def copy( + name: any.Name = this.name, + imports: Seq[any.Import] = this.imports, + parents: Seq[any.Type] = this.parents, + implemented: Seq[any.Type] = this.implemented, + fields: Seq[Field] = this.fields, + methods: Seq[any.Method] = this.methods, + constructors: Seq[Constructor] = this.constructors, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = this.constructorTypeLookupMap, + typeLookupMap: TypeRep => Generator[Class, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isInterface: Boolean = this.isInterface, + isStatic: Boolean = this.isStatic, + ): Class = ooFactory.cls( + name = name, + imports = imports, + parents = parents, + implemented = implemented, + methods = methods, + fields = fields, + constructors = constructors, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + typeLookupMap = typeLookupMap, + isAbstract = isAbstract, + isInterface = isInterface, + isStatic = isStatic, + ) + } + + trait MemberAccessExpression extends anyOverrides.Expression { + def getSelfMemberAccessExpression: ooFinalTypes.MemberAccessExpression + + def owner: any.Expression + def field: any.Name + + def copy( + owner: any.Expression = this.owner, + field: any.Name = this.field, + ): MemberAccessExpression = ooFactory.memberAccessExpression(owner = owner, field = field) + } + + trait SelfReferenceExpression extends anyOverrides.Expression { + def getSelfSelfReferenceExpression: ooFinalTypes.SelfReferenceExpression + } + + trait SuperReferenceExpression extends anyOverrides.Expression { + def getSelfSuperReferenceExpression: ooFinalTypes.SuperReferenceExpression + + def parentType: any.Type + + def copy( + parentType: any.Type = this.parentType, + ): SuperReferenceExpression = ooFactory.superReferenceExpression(parentType) + } + + trait ObjectInstantiationExpression extends anyOverrides.Expression { + def getSelfObjectInstantiationExpression: ooFinalTypes.ObjectInstantiationExpression + + def tpe: any.Type + def constructorArguments: Seq[any.Expression] + def body: Option[Class] = Option.empty + + def copy( + tpe: any.Type = this.tpe, + constructorArguments: Seq[any.Expression] = this.constructorArguments, + body: Option[Class] = this.body + ): ObjectInstantiationExpression = ooFactory.objectInstantiationExpression(tpe, constructorArguments, body) + } + + trait CastExpression extends anyOverrides.Expression { + def getSelfCastExpression: ooFinalTypes.CastExpression + + def tpe: any.Type + def expression: any.Expression + + def copy( + tpe: any.Type = this.tpe, + expression: any.Expression = this.expression + ): CastExpression = ooFactory.castExpression(tpe, expression) + } + + trait InstanceOfExpression extends anyOverrides.Expression { + def getSelfInstanceOfExpression: ooFinalTypes.InstanceOfExpression + + def tpe: any.Type + def expression: any.Expression + + def copy( + tpe: any.Type = this.tpe, + expression: any.Expression = this.expression + ): InstanceOfExpression = ooFactory.instanceOfExpression(tpe, expression) + } + + trait Constructor extends anyOverrides.Method { + def constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty + def getSelfConstructor: ooFinalTypes.Constructor + + override def isAbstract: Boolean = false + override def isOverride: Boolean = false + + def constructedType: Option[any.Type] = Option.empty + def superInitialization: Option[(any.Type, Seq[any.Expression])] = Option.empty + def fieldInitializers: Seq[(any.Name, any.Expression)] = Seq.empty + + def addConstructorTypeLookups(lookups: TypeRep => Option[Generator[Constructor, any.Type]]): Constructor = { + copyAsConstructor(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) + } + def toTargetLanguageTypeInConstructor(tpe: TypeRep): Generator[Constructor, any.Type] = constructorTypeLookupMap(tpe) + + override def copyAsClsMethod( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isStatic: Boolean = this.isStatic, + isPublic: Boolean = this.isPublic, + isOverride: Boolean = this.isOverride, + ): anyOverrides.Method = copyAsConstructor(this.constructedType, imports, statements, parameters, typeLookupMap) + + def copyAsConstructor( + constructedType: Option[any.Type] = this.constructedType, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = this.constructorTypeLookupMap, + superInitialization: Option[(any.Type, Seq[any.Expression])] = this.superInitialization, + fieldInitializers: Seq[(any.Name, any.Expression)] = this.fieldInitializers, + ): Constructor = ooFactory.constructor(constructedType, imports, statements, parameters, typeLookupMap, constructorTypeLookupMap, superInitialization, fieldInitializers) + } + + trait Field { + def getSelfField: ooFinalTypes.Field + + def name: any.Name + def tpe: any.Type + def init: Option[any.Expression] = Option.empty + + def copy( + name: any.Name = this.name, + tpe: any.Type = this.tpe, + init: Option[any.Expression] = this.init, + ): Field = ooFactory.field(name, tpe, init) + } + + trait ClassReferenceType extends any.Type { + def getSelfClassReferenceType: ooFinalTypes.ClassReferenceType + + def qualifiedClassName: Seq[any.Name] + + def copy( + qualifiedClassName: Seq[any.Name] = this.qualifiedClassName + ): ClassReferenceType = ooFactory.classReferenceType(qualifiedClassName*) + } + + + trait Factory { + def ooProject( + compilationUnits: Set[any.CompilationUnit] = Set.empty, + customFiles: Seq[FileWithPath] = Seq.empty, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty, + classTypeLookupMap: TypeRep => Generator[Class, any.Type] = Map.empty + ): anyOverrides.Project + + def ooCompilationUnit( + name: Seq[any.Name], + imports: Seq[any.Import], + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty, + classTypeLookupMap: TypeRep => Generator[Class, any.Type] = Map.empty, + classes: Seq[Class] = Seq.empty, + tests: Seq[any.TestSuite] = Seq.empty + ): anyOverrides.CompilationUnit + + def clsMethod( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + isAbstract: Boolean = false, + isStatic: Boolean = false, + isPublic: Boolean = false, + isOverride: Boolean = false + ): anyOverrides.Method + + def cls( + name: any.Name, + imports: Seq[any.Import] = Seq.empty, + parents: Seq[any.Type] = Seq.empty, + implemented: Seq[any.Type] = Seq.empty, + fields: Seq[Field] = Seq.empty, + methods: Seq[any.Method] = Seq.empty, + constructors: Seq[Constructor] = Seq.empty, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty, + typeLookupMap: TypeRep => Generator[Class, any.Type] = Map.empty, + isAbstract: Boolean = false, + isInterface: Boolean = false, + isStatic: Boolean = false, + ): Class + + def classBasedTestSuite(underlyingClass: Class, testMarkers: Seq[Boolean]): anyOverrides.TestSuite + + def constructor( + constructedType: Option[any.Type] = Option.empty, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[Constructor, any.Type] = Map.empty, + superInitialization: Option[(any.Type, Seq[any.Expression])] = Option.empty, + fieldInitializers: Seq[(any.Name, any.Expression)] = Seq.empty, + ): Constructor + + def field( + name: any.Name, + tpe: any.Type, + init: Option[any.Expression] = Option.empty, + ): Field + + def memberAccessExpression( + owner: any.Expression, + field: any.Name, + ): MemberAccessExpression + + def objectInstantiationExpression( + tpe: any.Type, + constructorArguments: Seq[any.Expression], + body: Option[Class] = Option.empty + ): ObjectInstantiationExpression + + def castExpression( + tpe: any.Type, + expression: any.Expression + ): CastExpression + + def instanceOfExpression( + tpe: any.Type, + expression: any.Expression + ): InstanceOfExpression + + def superReferenceExpression( + parentType: any.Type + ): SuperReferenceExpression + + def selfReferenceExpression: SelfReferenceExpression + + def classReferenceType(qualifiedClassName: any.Name*): ClassReferenceType + + implicit def convert(other: Class): ooFinalTypes.Class = other.getSelfClass + implicit def convert(other: Constructor): ooFinalTypes.Constructor = other.getSelfConstructor + implicit def convert(other: Field): ooFinalTypes.Field = other.getSelfField + implicit def convert(other: MemberAccessExpression): ooFinalTypes.MemberAccessExpression = other.getSelfMemberAccessExpression + implicit def convert(other: SelfReferenceExpression): ooFinalTypes.SelfReferenceExpression = other.getSelfSelfReferenceExpression + implicit def convert(other: ObjectInstantiationExpression): ooFinalTypes.ObjectInstantiationExpression = other.getSelfObjectInstantiationExpression + implicit def convert(other: CastExpression): ooFinalTypes.CastExpression = other.getSelfCastExpression + implicit def convert(other: InstanceOfExpression): ooFinalTypes.InstanceOfExpression = other.getSelfInstanceOfExpression + implicit def convert(other: SuperReferenceExpression): ooFinalTypes.SuperReferenceExpression = other.getSelfSuperReferenceExpression + implicit def convert(other: ClassReferenceType): ooFinalTypes.ClassReferenceType = other.getSelfClassReferenceType + } + } + + val finalTypes: oo.anyOverrides.FinalTypes + val ooFinalTypes: oo.FinalTypes + val factory: oo.anyOverrides.Factory + val ooFactory: oo.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOParadigm.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOParadigm.scala index ba0c318d..5db63150 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOParadigm.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/OOParadigm.scala @@ -1,72 +1,73 @@ package org.combinators.ep.language.inbetween.oo /*DI:LI:AI*/ -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, FileWithPath, Understands, paradigm} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AddBlockDefinitions, AddClass, AddConstructor, AddField, AddImplemented, AddImport, AddMethod, AddParent, AddTypeLookup, Apply, CastObject, Debug, FindClass, FreshName, GetArguments, GetConstructor, GetField, GetMember, InitializeField, InitializeParent, InstanceOfType, InstantiateObject, Reify, RemoveMethod, ResolveImport, SelfReference, SetAbstract, SetInterface, SetOverride, SetParameters, SetStatic, SuperReference, ToTargetLanguageType, ObjectOriented as OOP} +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.generator.paradigm.{AddBlockDefinitions, AddClass, AddConstructor, AddField, AddImplemented, AddImport, AddMethod, AddParent, AddTypeLookup, Apply, CastObject, Debug, FindClass, FreshName, GetArguments, GetConstructor, GetField, GetMember, InitializeField, InitializeParent, InstanceOfType, InstantiateObject, Reify, RemoveMethod, ResolveImport, SelfReference, SetAbstract, SetInterface, SetOverride, SetParameters, SetStatic, SuperReference, ToTargetLanguageType, ObjectOriented => OOP} -import org.combinators.ep.language.inbetween.any -trait OOParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends OOP { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.{FT=>_, _} - import syntax._ - lazy val factory: base.factory.type = base.factory - type ClassContext = Class[FT] - type MethodBodyContext = any.Method[FT] - type ConstructorContext = Constructor[FT] - type CompilationUnitContext = any.CompilationUnit[FT] +trait OOParadigm[AST <: OOAST, B](val base: AnyParadigm.WithAST[AST] & B) extends OOP { + import base.ast.any + import base.ast.factory + import base.ast.ooFactory + import base.ast.oo.* + import base.ast.any.* + import base.ProjectContext + import base.TestContext + type ClassContext = Class + type MethodBodyContext = Method + type ConstructorContext = Constructor + type CompilationUnitContext = CompilationUnit val classCapabilities: ClassCapabilities = new ClassCapabilities { - implicit val canDebugInClass: Understands[Class[FT], Debug] = new Understands[Class[FT], Debug] { - def perform(context: Class[FT], command: Debug): (Class[FT], Unit) = { + implicit val canDebugInClass: Understands[Class, Debug] = new Understands[Class, Debug] { + def perform(context: Class, command: Debug): (Class, Unit) = { println(command.tag) (context, ()) } } - implicit val canAddTypeLookupForMethodsInClass: Understands[Class[FT], AddTypeLookup[MethodBodyContext, Type]] = new Understands[Class[FT], AddTypeLookup[MethodBodyContext, Type]] { - def perform(context: Class[FT], command: AddTypeLookup[MethodBodyContext, Type]): (Class[FT], Unit) = { + implicit val canAddTypeLookupForMethodsInClass: Understands[Class, AddTypeLookup[MethodBodyContext, Type]] = new Understands[Class, AddTypeLookup[MethodBodyContext, Type]] { + def perform(context: Class, command: AddTypeLookup[MethodBodyContext, Type]): (Class, Unit) = { (context.addTypeLookupsForMethods((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } - implicit val canAddTypeLookupForClassesInClass: Understands[Class[FT], AddTypeLookup[Class[FT], Type]] = new Understands[Class[FT], AddTypeLookup[Class[FT], Type]] { - def perform(context: Class[FT], command: AddTypeLookup[Class[FT], Type]): (Class[FT], Unit) = { + implicit val canAddTypeLookupForClassesInClass: Understands[Class, AddTypeLookup[Class, Type]] = new Understands[Class, AddTypeLookup[Class, Type]] { + def perform(context: Class, command: AddTypeLookup[Class, Type]): (Class, Unit) = { (context.addTypeLookupsForClasses((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } - implicit val canAddTypeLookupForConstructorsInClass: Understands[Class[FT], AddTypeLookup[ConstructorContext, Type]] = new Understands[Class[FT], AddTypeLookup[ConstructorContext, Type]] { - def perform(context: Class[FT], command: AddTypeLookup[ConstructorContext, Type]): (Class[FT], Unit) = { + implicit val canAddTypeLookupForConstructorsInClass: Understands[Class, AddTypeLookup[ConstructorContext, Type]] = new Understands[Class, AddTypeLookup[ConstructorContext, Type]] { + def perform(context: Class, command: AddTypeLookup[ConstructorContext, Type]): (Class, Unit) = { (context.addTypeLookupsForConstructors((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } - implicit val canAddParentInClass: Understands[Class[FT], AddParent[Type]] = new Understands[Class[FT], AddParent[Type]] { - def perform(context: Class[FT], command: AddParent[Type]): (Class[FT], Unit) = { + implicit val canAddParentInClass: Understands[Class, AddParent[Type]] = new Understands[Class, AddParent[Type]] { + def perform(context: Class, command: AddParent[Type]): (Class, Unit) = { (context.copy(parents = context.parents :+ command.parentClass), ()) } } - implicit val canAddImplementedInClass: Understands[Class[FT], AddImplemented[Type]] = new Understands[Class[FT], AddImplemented[Type]] { - def perform(context: Class[FT], command: AddImplemented[Type]): (Class[FT], Unit) = { + implicit val canAddImplementedInClass: Understands[Class, AddImplemented[Type]] = new Understands[Class, AddImplemented[Type]] { + def perform(context: Class, command: AddImplemented[Type]): (Class, Unit) = { (context.copy(implemented = context.implemented :+ command.interface), ()) } } - implicit val canRemoveMethodFromClass: Understands[Class[FT], RemoveMethod[Type, Name]] = new Understands[Class[FT], RemoveMethod[Type, Name]] { - override def perform(context: Class[FT], command: RemoveMethod[Type, Name]): (Class[FT], Unit) = { + implicit val canRemoveMethodFromClass: Understands[Class, RemoveMethod[Type, Name]] = new Understands[Class, RemoveMethod[Type, Name]] { + override def perform(context: Class, command: RemoveMethod[Type, Name]): (Class, Unit) = { ??? // TODO: Remove me } } - implicit val canAddFieldInClass: Understands[Class[FT], AddField[Name, Type, Expression]] = new Understands[Class[FT], AddField[Name, Type, Expression]] { - def perform(context: Class[FT], command: AddField[Name, Type, Expression]): (Class[FT], Unit) = { - (context.copy(fields = context.fields :+ factory.field(command.name, command.tpe, command.initializer)), ()) + implicit val canAddFieldInClass: Understands[Class, AddField[Name, Type, Expression]] = new Understands[Class, AddField[Name, Type, Expression]] { + def perform(context: Class, command: AddField[Name, Type, Expression]): (Class, Unit) = { + (context.copy(fields = context.fields :+ ooFactory.field(command.name, command.tpe, command.initializer)), ()) } } - implicit val canGetFieldInClass: Understands[Class[FT], GetField[Name, Expression]] = new Understands[Class[FT], GetField[Name, Expression]] { - def perform(context: Class[FT], command: GetField[Name, Expression]): (Class[FT], Expression) = { - (context, factory.memberAccessExpression(factory.selfReferenceExpression, context.fields.find(f => f.name == command.name).get.name)) + implicit val canGetFieldInClass: Understands[Class, GetField[Name, Expression]] = new Understands[Class, GetField[Name, Expression]] { + def perform(context: Class, command: GetField[Name, Expression]): (Class, Expression) = { + (context, ooFactory.memberAccessExpression(ooFactory.selfReferenceExpression, context.fields.find(f => f.name == command.name).get.name)) } } - implicit val canAddMethodInClass: Understands[Class[FT], AddMethod[MethodBodyContext, Name, Option[Expression]]] = new Understands[Class[FT], AddMethod[MethodBodyContext, Name, Option[Expression]]] { - def perform(context: Class[FT], command: AddMethod[MethodBodyContext, Name, Option[Expression]]): (Class[FT], Unit) = { - val converted = factory.convert(context) - val emptyMethod = factory.clsMethod( + implicit val canAddMethodInClass: Understands[Class, AddMethod[MethodBodyContext, Name, Option[Expression]]] = new Understands[Class, AddMethod[MethodBodyContext, Name, Option[Expression]]] { + def perform(context: Class, command: AddMethod[MethodBodyContext, Name, Option[Expression]]): (Class, Unit) = { + val converted = ooFactory.convert(context) + val emptyMethod = ooFactory.clsMethod( name = command.name, isPublic = command.isPublic, isOverride = command.isOverride, @@ -79,212 +80,212 @@ trait OOParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends OOP { (context.copy(methods = context.methods :+ generatedMethod), ()) } } - implicit val canAddConstructorInClass: Understands[Class[FT], AddConstructor[ConstructorContext]] = new Understands[Class[FT], AddConstructor[ConstructorContext]] { - def perform(context: Class[FT], command: AddConstructor[Constructor[FT]]): (Class[FT], Unit) = { - val converted = factory.convert(context) - val emptyConstructor = factory.constructor( - constructedType = Some(factory.classReferenceType(context.name)), + implicit val canAddConstructorInClass: Understands[Class, AddConstructor[ConstructorContext]] = new Understands[Class, AddConstructor[ConstructorContext]] { + def perform(context: Class, command: AddConstructor[Constructor]): (Class, Unit) = { + val converted = ooFactory.convert(context) + val emptyConstructor = ooFactory.constructor( + constructedType = Some(ooFactory.classReferenceType(context.name)), constructorTypeLookupMap = context.constructorTypeLookupMap, typeLookupMap = context.methodTypeLookupMap) val (generatedConstructor, ()) = Command.runGenerator(command.ctor, emptyConstructor) (context.copy(constructors = context.constructors :+ generatedConstructor), ()) } } - implicit val canAddImportInClass: Understands[Class[FT], AddImport[Import]] = new Understands[Class[FT], AddImport[Import]] { - def perform(context: Class[FT], command: AddImport[Import]): (Class[FT], Unit) = { + implicit val canAddImportInClass: Understands[Class, AddImport[Import]] = new Understands[Class, AddImport[Import]] { + def perform(context: Class, command: AddImport[Import]): (Class, Unit) = { (context.copy(imports = (context.imports :+ command.imp).distinct), ()) } } - implicit val canResolveImportInClass: Understands[Class[FT], ResolveImport[Import, Type]] = new Understands[Class[FT], ResolveImport[Import, Type]] { - def perform(context: Class[FT], command: ResolveImport[Import, Type]): (Class[FT], Option[Import]) = { + implicit val canResolveImportInClass: Understands[Class, ResolveImport[Import, Type]] = new Understands[Class, ResolveImport[Import, Type]] { + def perform(context: Class, command: ResolveImport[Import, Type]): (Class, Option[Import]) = { (context, context.resolveImport(command.forElem).headOption) } } - implicit val canSetAbstractInClass: Understands[Class[FT], SetAbstract] = new Understands[Class[FT], SetAbstract] { - def perform(context: Class[FT], command: SetAbstract): (Class[FT], Unit) = { + implicit val canSetAbstractInClass: Understands[Class, SetAbstract] = new Understands[Class, SetAbstract] { + def perform(context: Class, command: SetAbstract): (Class, Unit) = { (context.copy(isAbstract = true), ()) } } - implicit val canSetStaticInClass: Understands[Class[FT], SetStatic] = new Understands[Class[FT], SetStatic] { - def perform(context: Class[FT], command: SetStatic): (Class[FT], Unit) = { + implicit val canSetStaticInClass: Understands[Class, SetStatic] = new Understands[Class, SetStatic] { + def perform(context: Class, command: SetStatic): (Class, Unit) = { (context.copy(isStatic = true), ()) } } - implicit val canSetInterfaceInClass: Understands[Class[FT], SetInterface] = new Understands[Class[FT], SetInterface] { - def perform(context: Class[FT], command: SetInterface): (Class[FT], Unit) = { + implicit val canSetInterfaceInClass: Understands[Class, SetInterface] = new Understands[Class, SetInterface] { + def perform(context: Class, command: SetInterface): (Class, Unit) = { (context.copy(isInterface = true), ()) } } - implicit val canTranslateTypeInClass: Understands[Class[FT], ToTargetLanguageType[Type]] = new Understands[Class[FT], ToTargetLanguageType[Type]] { - def perform(context: Class[FT], command: ToTargetLanguageType[Type]): (Class[FT], Type) = { + implicit val canTranslateTypeInClass: Understands[Class, ToTargetLanguageType[Type]] = new Understands[Class, ToTargetLanguageType[Type]] { + def perform(context: Class, command: ToTargetLanguageType[Type]): (Class, Type) = { Command.runGenerator(context.toTargetLanguageType(command.tpe), context) } } - implicit val canSelfReferenceInClass: Understands[Class[FT], SelfReference[Expression]] = new Understands[Class[FT], SelfReference[Expression]] { - def perform(context: Class[FT], command: SelfReference[Expression]): (Class[FT], Expression) = { - (context, factory.selfReferenceExpression) + implicit val canSelfReferenceInClass: Understands[Class, SelfReference[Expression]] = new Understands[Class, SelfReference[Expression]] { + def perform(context: Class, command: SelfReference[Expression]): (Class, Expression) = { + (context, ooFactory.selfReferenceExpression) } } - implicit val canFindClassInClass: Understands[Class[FT], FindClass[Name, Type]] = new Understands[Class[FT], FindClass[Name, Type]] { - def perform(context: Class[FT], command: FindClass[Name, Type]): (Class[FT], Type) = { - (context, context.findClass(command.qualifiedName:_*)) + implicit val canFindClassInClass: Understands[Class, FindClass[Name, Type]] = new Understands[Class, FindClass[Name, Type]] { + def perform(context: Class, command: FindClass[Name, Type]): (Class, Type) = { + (context, context.findClass(command.qualifiedName*)) } } - implicit val canGetFreshNameInClass: Understands[Class[FT], FreshName[Name]] = new Understands[Class[FT], FreshName[Name]] { - def perform(context: Class[FT], command: FreshName[Name]): (Class[FT], Name) = { + implicit val canGetFreshNameInClass: Understands[Class, FreshName[Name]] = new Understands[Class, FreshName[Name]] { + def perform(context: Class, command: FreshName[Name]): (Class, Name) = { (context, context.getFreshName(command.basedOn)) } } } val constructorCapabilities: ConstructorCapabilities = new ConstructorCapabilities { - implicit val canInitializeParentInConstructor: Understands[Constructor[FT], InitializeParent[Type, Expression]] = new Understands[Constructor[FT], InitializeParent[Type, Expression]] { - def perform(context: Constructor[FT], command: InitializeParent[Type, Expression]): (Constructor[FT], Unit) = { + implicit val canInitializeParentInConstructor: Understands[Constructor, InitializeParent[Type, Expression]] = new Understands[Constructor, InitializeParent[Type, Expression]] { + def perform(context: Constructor, command: InitializeParent[Type, Expression]): (Constructor, Unit) = { (context.copyAsConstructor(superInitialization = Some((command.parent, command.arguments))), ()) } } - implicit val canCastInConstructor: Understands[Constructor[FT], CastObject[Type, Expression]] = new Understands[Constructor[FT], CastObject[Type, Expression]] { - def perform(context: Constructor[FT], command: CastObject[Type, Expression]): (Constructor[FT], Expression) = { - (context, factory.castExpression(command.tpe, command.expr)) + implicit val canCastInConstructor: Understands[Constructor, CastObject[Type, Expression]] = new Understands[Constructor, CastObject[Type, Expression]] { + def perform(context: Constructor, command: CastObject[Type, Expression]): (Constructor, Expression) = { + (context, ooFactory.castExpression(command.tpe, command.expr)) } } - implicit val canInitializeFieldInConstructor: Understands[Constructor[FT], InitializeField[Name, Expression]] = new Understands[Constructor[FT], InitializeField[Name, Expression]] { - def perform(context: Constructor[FT], command: InitializeField[Name, Expression]): (Constructor[FT], Unit) = { + implicit val canInitializeFieldInConstructor: Understands[Constructor, InitializeField[Name, Expression]] = new Understands[Constructor, InitializeField[Name, Expression]] { + def perform(context: Constructor, command: InitializeField[Name, Expression]): (Constructor, Unit) = { (context.copyAsConstructor(fieldInitializers = context.fieldInitializers :+ (command.name, command.value)), ()) } } - implicit val canAddBlockDefinitionsInConstructor: Understands[Constructor[FT], AddBlockDefinitions[Statement]] = new Understands[Constructor[FT], AddBlockDefinitions[Statement]] { - def perform(context: Constructor[FT], command: AddBlockDefinitions[Statement]): (Constructor[FT], Unit) = { + implicit val canAddBlockDefinitionsInConstructor: Understands[Constructor, AddBlockDefinitions[Statement]] = new Understands[Constructor, AddBlockDefinitions[Statement]] { + def perform(context: Constructor, command: AddBlockDefinitions[Statement]): (Constructor, Unit) = { (context.copyAsConstructor(statements = context.statements ++ command.definitions), ()) } } - implicit val canAddImportInConstructor: Understands[Constructor[FT], AddImport[Import]] = new Understands[Constructor[FT], AddImport[Import]] { - def perform(context: Constructor[FT], command: AddImport[Import]): (Constructor[FT], Unit) = { + implicit val canAddImportInConstructor: Understands[Constructor, AddImport[Import]] = new Understands[Constructor, AddImport[Import]] { + def perform(context: Constructor, command: AddImport[Import]): (Constructor, Unit) = { (context.copyAsConstructor(imports = context.imports + command.imp), ()) } } - implicit val canResolveImportInConstructor: Understands[Constructor[FT], ResolveImport[Import, Type]] = new Understands[Constructor[FT], ResolveImport[Import, Type]] { - def perform(context: Constructor[FT], command: ResolveImport[Import, Type]): (Constructor[FT], Option[Import]) = { + implicit val canResolveImportInConstructor: Understands[Constructor, ResolveImport[Import, Type]] = new Understands[Constructor, ResolveImport[Import, Type]] { + def perform(context: Constructor, command: ResolveImport[Import, Type]): (Constructor, Option[Import]) = { (context, context.resolveImport(command.forElem).headOption) } } - implicit val canInstantiateObjectInConstructor: Understands[Constructor[FT], InstantiateObject[Type, Expression, Class[FT]]] = new Understands[Constructor[FT], InstantiateObject[Type, Expression, Class[FT]]] { - def perform(context: Constructor[FT], command: InstantiateObject[Type, Expression, Class[FT]]): (Constructor[FT], Expression) = { - (context, factory.objectInstantiationExpression(command.tpe, command.constructorArguments, None)) // TODO: add anonymous inner class declarations + implicit val canInstantiateObjectInConstructor: Understands[Constructor, InstantiateObject[Type, Expression, Class]] = new Understands[Constructor, InstantiateObject[Type, Expression, Class]] { + def perform(context: Constructor, command: InstantiateObject[Type, Expression, Class]): (Constructor, Expression) = { + (context, ooFactory.objectInstantiationExpression(command.tpe, command.constructorArguments, None)) // TODO: add anonymous inner class declarations } } - implicit val canApplyInConstructor: Understands[Constructor[FT], Apply[Expression, Expression, Expression]] = new Understands[Constructor[FT], Apply[Expression, Expression, Expression]] { - def perform(context: Constructor[FT], command: Apply[Expression, Expression, Expression]): (Constructor[FT], Expression) = { + implicit val canApplyInConstructor: Understands[Constructor, Apply[Expression, Expression, Expression]] = new Understands[Constructor, Apply[Expression, Expression, Expression]] { + def perform(context: Constructor, command: Apply[Expression, Expression, Expression]): (Constructor, Expression) = { (context, factory.applyExpression(command.functional, command.arguments)) } } - implicit val canGetMemberInConstructor: Understands[Constructor[FT], GetMember[Expression, Name]] = new Understands[Constructor[FT], GetMember[Expression, Name]] { - def perform(context: Constructor[FT], command: GetMember[Expression, Name]): (Constructor[FT], Expression) = { - (context, factory.memberAccessExpression(command.instance, command.member)) + implicit val canGetMemberInConstructor: Understands[Constructor, GetMember[Expression, Name]] = new Understands[Constructor, GetMember[Expression, Name]] { + def perform(context: Constructor, command: GetMember[Expression, Name]): (Constructor, Expression) = { + (context, ooFactory.memberAccessExpression(command.instance, command.member)) } } - implicit val canSelfReferenceInConstructor: Understands[Constructor[FT], SelfReference[Expression]] = new Understands[Constructor[FT], SelfReference[Expression]] { - def perform(context: Constructor[FT], command: SelfReference[Expression]): (Constructor[FT], Expression) = { - (context, factory.selfReferenceExpression) + implicit val canSelfReferenceInConstructor: Understands[Constructor, SelfReference[Expression]] = new Understands[Constructor, SelfReference[Expression]] { + def perform(context: Constructor, command: SelfReference[Expression]): (Constructor, Expression) = { + (context, ooFactory.selfReferenceExpression) } } - implicit val canGetArgumentsInConstructor: Understands[Constructor[FT], GetArguments[Type, Name, Expression]] = new Understands[Constructor[FT], GetArguments[Type, Name, Expression]] { - def perform(context: Constructor[FT], command: GetArguments[Type, Name, Expression]): (Constructor[FT], Seq[(Name, Type, Expression)]) = { + implicit val canGetArgumentsInConstructor: Understands[Constructor, GetArguments[Type, Name, Expression]] = new Understands[Constructor, GetArguments[Type, Name, Expression]] { + def perform(context: Constructor, command: GetArguments[Type, Name, Expression]): (Constructor, Seq[(Name, Type, Expression)]) = { (context, context.parameters.map(param => (param._1, param._2, factory.argumentExpression(param._1)))) } } - implicit val canTranslateTypeInConstructor: Understands[Constructor[FT], ToTargetLanguageType[Type]] = new Understands[Constructor[FT], ToTargetLanguageType[Type]] { - def perform(context: Constructor[FT], command: ToTargetLanguageType[Type]): (Constructor[FT], Type) = { + implicit val canTranslateTypeInConstructor: Understands[Constructor, ToTargetLanguageType[Type]] = new Understands[Constructor, ToTargetLanguageType[Type]] { + def perform(context: Constructor, command: ToTargetLanguageType[Type]): (Constructor, Type) = { Command.runGenerator(context.toTargetLanguageTypeInConstructor(command.tpe), context) } } - implicit def canReifyInConstructor[T]: Understands[Constructor[FT], Reify[T, Expression]] = new Understands[Constructor[FT], Reify[T, Expression]] { - def perform(context: Constructor[FT], command: Reify[T, Expression]): (Constructor[FT], Expression) = { + implicit def canReifyInConstructor[T]: Understands[Constructor, Reify[T, Expression]] = new Understands[Constructor, Reify[T, Expression]] { + def perform(context: Constructor, command: Reify[T, Expression]): (Constructor, Expression) = { (context, context.reify(command.tpe, command.value)) } } - implicit val canSetParametersInConstructor: Understands[Constructor[FT], SetParameters[Name, Type]] = new Understands[Constructor[FT], SetParameters[Name, Type]] { - def perform(context: Constructor[FT], command: SetParameters[Name, Type]): (Constructor[FT], Unit) = { + implicit val canSetParametersInConstructor: Understands[Constructor, SetParameters[Name, Type]] = new Understands[Constructor, SetParameters[Name, Type]] { + def perform(context: Constructor, command: SetParameters[Name, Type]): (Constructor, Unit) = { (context.copyAsConstructor(parameters = command.params), ()) } } - implicit val canGetConstructorInConstructor: Understands[Constructor[FT], GetConstructor[Type, Expression]] = new Understands[Constructor[FT], GetConstructor[Type, Expression]] { - def perform(context: Constructor[FT], command: GetConstructor[Type, Expression]): (Constructor[FT], Expression) = { + implicit val canGetConstructorInConstructor: Understands[Constructor, GetConstructor[Type, Expression]] = new Understands[Constructor, GetConstructor[Type, Expression]] { + def perform(context: Constructor, command: GetConstructor[Type, Expression]): (Constructor, Expression) = { ??? } } - implicit val canFindClassInConstructor: Understands[Constructor[FT], FindClass[Name, Type]] = new Understands[Constructor[FT], FindClass[Name, Type]] { - def perform(context: Constructor[FT], command: FindClass[Name, Type]): (Constructor[FT], Type) = { - (context, context.findClass(command.qualifiedName: _*)) + implicit val canFindClassInConstructor: Understands[Constructor, FindClass[Name, Type]] = new Understands[Constructor, FindClass[Name, Type]] { + def perform(context: Constructor, command: FindClass[Name, Type]): (Constructor, Type) = { + (context, context.findClass(command.qualifiedName*)) } } - implicit val canGetFreshNameInConstructor: Understands[Constructor[FT], FreshName[Name]] = new Understands[Constructor[FT], FreshName[Name]] { - def perform(context: Constructor[FT], command: FreshName[Name]): (Constructor[FT], Name) = { + implicit val canGetFreshNameInConstructor: Understands[Constructor, FreshName[Name]] = new Understands[Constructor, FreshName[Name]] { + def perform(context: Constructor, command: FreshName[Name]): (Constructor, Name) = { (context, context.getFreshName(command.basedOn)) } } } val methodBodyCapabilities: MethodBodyCapabilities = new MethodBodyCapabilities { - implicit val canInstantiateObjectInMethod: Understands[MethodBodyContext, InstantiateObject[Type, Expression, ClassContext]] = new Understands[MethodBodyContext, InstantiateObject[Type, Expression, Class[FT]]] { - def perform(context: any.Method[FT], command: InstantiateObject[Type, Expression, Class[FT]]): (any.Method[FT], Expression) = { - (context, factory.objectInstantiationExpression(command.tpe, command.constructorArguments, None)) // TODO: add anonymous inner class declarations + implicit val canInstantiateObjectInMethod: Understands[MethodBodyContext, InstantiateObject[Type, Expression, ClassContext]] = new Understands[MethodBodyContext, InstantiateObject[Type, Expression, Class]] { + def perform(context: any.Method, command: InstantiateObject[Type, Expression, Class]): (any.Method, Expression) = { + (context, ooFactory.objectInstantiationExpression(command.tpe, command.constructorArguments, None)) // TODO: add anonymous inner class declarations } } - implicit val canGetMemberInMethod: Understands[any.Method[FT], GetMember[Expression, Name]] = new Understands[any.Method[FT], GetMember[Expression, Name]] { - def perform(context: any.Method[FT], command: GetMember[Expression, Name]): (any.Method[FT], Expression) = { - (context, factory.memberAccessExpression(command.instance, command.member)) + implicit val canGetMemberInMethod: Understands[any.Method, GetMember[Expression, Name]] = new Understands[any.Method, GetMember[Expression, Name]] { + def perform(context: any.Method, command: GetMember[Expression, Name]): (any.Method, Expression) = { + (context, ooFactory.memberAccessExpression(command.instance, command.member)) } } - implicit val canCastInMethod: Understands[any.Method[FT], CastObject[Type, Expression]] = new Understands[any.Method[FT], CastObject[Type, Expression]] { - def perform(context: any.Method[FT], command: CastObject[Type, Expression]): (any.Method[FT], Expression) = { - (context, factory.castExpression(command.tpe, command.expr)) + implicit val canCastInMethod: Understands[any.Method, CastObject[Type, Expression]] = new Understands[any.Method, CastObject[Type, Expression]] { + def perform(context: any.Method, command: CastObject[Type, Expression]): (any.Method, Expression) = { + (context, ooFactory.castExpression(command.tpe, command.expr)) } } - implicit val canInstanceOfTypeInMethod: Understands[any.Method[FT], InstanceOfType[Type, Expression]] = new Understands[any.Method[FT], InstanceOfType[Type, Expression]] { - def perform(context: any.Method[FT], command: InstanceOfType[Type, Expression]): (any.Method[FT], Expression) = { - (context, factory.instanceOfExpression(command.tpe, command.expr)) + implicit val canInstanceOfTypeInMethod: Understands[any.Method, InstanceOfType[Type, Expression]] = new Understands[any.Method, InstanceOfType[Type, Expression]] { + def perform(context: any.Method, command: InstanceOfType[Type, Expression]): (any.Method, Expression) = { + (context, ooFactory.instanceOfExpression(command.tpe, command.expr)) } } - implicit val canSetAbstractInMethod: Understands[any.Method[FT], SetAbstract] = new Understands[any.Method[FT], SetAbstract] { - def perform(context: any.Method[FT], command: SetAbstract): (any.Method[FT], Unit) = { + implicit val canSetAbstractInMethod: Understands[any.Method, SetAbstract] = new Understands[any.Method, SetAbstract] { + def perform(context: any.Method, command: SetAbstract): (any.Method, Unit) = { (factory.convert(context).copyAsClsMethod(isAbstract = true), ()) } } - implicit val canSetStaticInMethod: Understands[any.Method[FT], SetStatic] = new Understands[any.Method[FT], SetStatic] { - def perform(context: any.Method[FT], command: SetStatic): (any.Method[FT], Unit) = { + implicit val canSetStaticInMethod: Understands[any.Method, SetStatic] = new Understands[any.Method, SetStatic] { + def perform(context: any.Method, command: SetStatic): (any.Method, Unit) = { (factory.convert(context).copyAsClsMethod(isStatic = true), ()) } } - implicit val canSetOverrideInMethod: Understands[any.Method[FT], SetOverride] = new Understands[any.Method[FT], SetOverride] { - def perform(context: any.Method[FT], command: SetOverride): (any.Method[FT], Unit) = { + implicit val canSetOverrideInMethod: Understands[any.Method, SetOverride] = new Understands[any.Method, SetOverride] { + def perform(context: any.Method, command: SetOverride): (any.Method, Unit) = { (factory.convert(context).copyAsClsMethod(isOverride = true), ()) } } - implicit val canSelfReferenceInMethod: Understands[any.Method[FT], SelfReference[Expression]] = new Understands[any.Method[FT], SelfReference[Expression]] { - def perform(context: any.Method[FT], command: SelfReference[Expression]): (any.Method[FT], Expression) = { - (context, factory.selfReferenceExpression) + implicit val canSelfReferenceInMethod: Understands[any.Method, SelfReference[Expression]] = new Understands[any.Method, SelfReference[Expression]] { + def perform(context: any.Method, command: SelfReference[Expression]): (any.Method, Expression) = { + (context, ooFactory.selfReferenceExpression) } } - implicit val canSuperReferenceInMethod: Understands[any.Method[FT], SuperReference[Name, Expression]] = new Understands[any.Method[FT], SuperReference[Name, Expression]] { - def perform(context: any.Method[FT], command: SuperReference[Name, Expression]): (any.Method[FT], Expression) = { - (context, factory.superReferenceExpression(factory.convert(context).findClass(command.qualifiedName: _*))) + implicit val canSuperReferenceInMethod: Understands[any.Method, SuperReference[Name, Expression]] = new Understands[any.Method, SuperReference[Name, Expression]] { + def perform(context: any.Method, command: SuperReference[Name, Expression]): (any.Method, Expression) = { + (context, ooFactory.superReferenceExpression(factory.convert(context).findClass(command.qualifiedName*))) } } - implicit val canGetConstructorInMethod: Understands[any.Method[FT], GetConstructor[Type, Expression]] = new Understands[any.Method[FT], GetConstructor[Type, Expression]] { - def perform(context: any.Method[FT], command: GetConstructor[Type, Expression]): (any.Method[FT], Expression) = { + implicit val canGetConstructorInMethod: Understands[any.Method, GetConstructor[Type, Expression]] = new Understands[any.Method, GetConstructor[Type, Expression]] { + def perform(context: any.Method, command: GetConstructor[Type, Expression]): (any.Method, Expression) = { ??? // TODO: Remove } } - implicit val canFindClassInMethod: Understands[any.Method[FT], FindClass[Name, Type]] = new Understands[any.Method[FT], FindClass[Name, Type]] { - def perform(context: any.Method[FT], command: FindClass[Name, Type]): (any.Method[FT], Type) = { - (context, factory.convert(context).findClass(command.qualifiedName: _*)) + implicit val canFindClassInMethod: Understands[any.Method, FindClass[Name, Type]] = new Understands[any.Method, FindClass[Name, Type]] { + def perform(context: any.Method, command: FindClass[Name, Type]): (any.Method, Type) = { + (context, factory.convert(context).findClass(command.qualifiedName*)) } } } val compilationUnitCapabilities: CompilationUnitCapabilities = new CompilationUnitCapabilities { - implicit val canAddClassInCompilationUnit: Understands[CompilationUnit, AddClass[Class[FT], Name]] = new Understands[CompilationUnit, AddClass[Class[FT], Name]] { - def perform(context: CompilationUnit, command: AddClass[Class[FT], Name]): (CompilationUnit, Unit) = { + implicit val canAddClassInCompilationUnit: Understands[CompilationUnit, AddClass[Class, Name]] = new Understands[CompilationUnit, AddClass[Class, Name]] { + def perform(context: CompilationUnit, command: AddClass[Class, Name]): (CompilationUnit, Unit) = { val converted = factory.convert(context) - val emptyCls = factory.cls( + val emptyCls = ooFactory.cls( name = command.name, methodTypeLookupMap = converted.methodTypeLookupMap, constructorTypeLookupMap = converted.constructorTypeLookupMap, @@ -295,26 +296,26 @@ trait OOParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends OOP { } } val projectCapabilities: ProjectCapabilities = new ProjectCapabilities { - implicit val canAddTypeLookupForClassesInProject: Understands[ProjectContext, AddTypeLookup[Class[FT], Type]] = new Understands[ProjectContext, AddTypeLookup[Class[FT], Type]] { - def perform(context: ProjectContext, command: AddTypeLookup[Class[FT], Type]): (ProjectContext, Unit) = { + implicit val canAddTypeLookupForClassesInProject: Understands[ProjectContext, AddTypeLookup[Class, Type]] = new Understands[ProjectContext, AddTypeLookup[Class, Type]] { + def perform(context: ProjectContext, command: AddTypeLookup[Class, Type]): (ProjectContext, Unit) = { (factory.convert(context).addTypeLookupsForClasses((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } - implicit val canAddTypeLookupForConstructorsInProject: Understands[ProjectContext, AddTypeLookup[Constructor[FT], Type]] = new Understands[ProjectContext, AddTypeLookup[Constructor[FT], Type]] { - def perform(context: ProjectContext, command: AddTypeLookup[Constructor[FT], Type]): (ProjectContext, Unit) = { + implicit val canAddTypeLookupForConstructorsInProject: Understands[ProjectContext, AddTypeLookup[Constructor, Type]] = new Understands[ProjectContext, AddTypeLookup[Constructor, Type]] { + def perform(context: ProjectContext, command: AddTypeLookup[Constructor, Type]): (ProjectContext, Unit) = { (factory.convert(context).addTypeLookupsForConstructors((tpeRep: TypeRep) => if (tpeRep == command.tpe) Some(command.lookup) else None), ()) } } } val testCapabilities: TestCapabilities = new TestCapabilities { implicit val canAddMethodInTest: Understands[TestContext, AddMethod[MethodBodyContext, Name, Option[Expression]]] = new Understands[TestContext, AddMethod[MethodBodyContext, Name, Option[Expression]]] { - def perform(context: TestContext, command: AddMethod[MethodBodyContext, Name, Option[Expression]]): (TestContext, Unit) = { - val clsBasedTestSuite = factory.convert(context) - import classCapabilities.canAddMethodInClass - val (updatedCls, ()) = Command.runGenerator(classCapabilities.addMethod(command.name, command.spec), clsBasedTestSuite.underlyingClass) - (clsBasedTestSuite.copyAsClassBasedTestSuite(underlyingClass = updatedCls, testMarkers = clsBasedTestSuite.testMarkers :+ false), ()) - } + def perform(context: TestContext, command: AddMethod[MethodBodyContext, Name, Option[Expression]]): (TestContext, Unit) = { + val clsBasedTestSuite = factory.convert(context) + import classCapabilities.canAddMethodInClass + val (updatedCls, ()) = Command.runGenerator(classCapabilities.addMethod(command.name, command.spec), clsBasedTestSuite.underlyingClass) + (clsBasedTestSuite.copyAsClassBasedTestSuite(underlyingClass = updatedCls, testMarkers = clsBasedTestSuite.testMarkers :+ false), ()) } + } implicit val canAddBlockDefinitionsInTest: Understands[TestContext, AddBlockDefinitions[Statement]] = new Understands[TestContext, AddBlockDefinitions[Statement]] { def perform(context: TestContext, command: AddBlockDefinitions[Statement]): (TestContext, Unit) = { val clsBasedTestSuite = factory.convert(context) @@ -376,11 +377,11 @@ trait OOParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends OOP { } implicit val canInstantiateObjectInTest: Understands[TestContext, InstantiateObject[Type, Expression, TestContext]] = new Understands[TestContext, InstantiateObject[Type, Expression, TestContext]] { def perform(context: TestContext, command: InstantiateObject[Type, Expression, TestContext]): (TestContext, Expression) = { - (context, factory.objectInstantiationExpression(command.tpe, command.constructorArguments, None)) // TODO: Add anon inner class + (context, ooFactory.objectInstantiationExpression(command.tpe, command.constructorArguments, None)) // TODO: Add anon inner class } } - implicit val canAddConstructorInTest: Understands[TestContext, AddConstructor[Constructor[FT]]] = new Understands[TestContext, AddConstructor[Constructor[FT]]] { - def perform(context: TestContext, command: AddConstructor[Constructor[FT]]): (TestContext, Unit) = { + implicit val canAddConstructorInTest: Understands[TestContext, AddConstructor[Constructor]] = new Understands[TestContext, AddConstructor[Constructor]] { + def perform(context: TestContext, command: AddConstructor[Constructor]): (TestContext, Unit) = { val clsBasedTestSuite = factory.convert(context) import classCapabilities.canAddConstructorInClass val (updatedCls, ()) = Command.runGenerator(classCapabilities.addConstructor(command.ctor), clsBasedTestSuite.underlyingClass) @@ -407,7 +408,7 @@ trait OOParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends OOP { def perform(context: TestContext, command: FindClass[Name, Type]): (TestContext, Type) = { val clsBasedTestSuite = factory.convert(context) import classCapabilities.canFindClassInClass - val (updatedCls, result) = Command.runGenerator(classCapabilities.findClass(command.qualifiedName: _*), clsBasedTestSuite.underlyingClass) + val (updatedCls, result) = Command.runGenerator(classCapabilities.findClass(command.qualifiedName*), clsBasedTestSuite.underlyingClass) (clsBasedTestSuite.copyAsClassBasedTestSuite(underlyingClass = updatedCls), result) } } @@ -423,8 +424,6 @@ trait OOParadigm[FT <: FinalTypes, FactoryType <: Factory[FT]] extends OOP { } object OOParadigm { - type WithBase[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = OOParadigm[FT, FactoryType] { val base: B } - def apply[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new OOParadigm[FT, FactoryType] { - val base: _base.type = _base - } + type WithBase[AST <: OOAST, B <: AnyParadigm.WithAST[AST]] = OOParadigm[AST, B] { } + def apply[AST <: OOAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new OOParadigm[AST, B](_base) {} } diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/package.scala deleted file mode 100644 index c08e1178..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/oo/package.scala +++ /dev/null @@ -1,510 +0,0 @@ -package org.combinators.ep.language.inbetween /*DI:LI:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator - -package object oo { - trait FinalTypes extends any.FinalTypes { - type Class - type Constructor - type Field - type MemberAccessExpression <: Expression - type SelfReferenceExpression <: Expression - type ObjectInstantiationExpression <: Expression - type CastExpression <: Expression - type InstanceOfExpression <: Expression - type SuperReferenceExpression <: Expression - type ClassReferenceType <: Type - } - - trait Project[FT <: FinalTypes] extends any.Project[FT] with Factory[FT] { - def methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - def constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty - def classTypeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = Map.empty - - override def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method[FT], any.Type[FT]]]): any.Project[FT] = - copyAsProjectWithTypeLookups(methodTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.methodTypeLookupMap(tpeRep))) - - def addTypeLookupsForConstructors(lookups: TypeRep => Option[Generator[oo.Constructor[FT], any.Type[FT]]]): any.Project[FT] = - copyAsProjectWithTypeLookups(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) - - def addTypeLookupsForClasses(lookups: TypeRep => Option[Generator[oo.Class[FT], any.Type[FT]]]): any.Project[FT] = - copyAsProjectWithTypeLookups(classTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.classTypeLookupMap(tpeRep))) - - override def copy( - compilationUnits: Set[any.CompilationUnit[FT]] - ): any.Project[FT] = copyAsProjectWithTypeLookups(compilationUnits) - - def copyAsProjectWithTypeLookups( - compilationUnits: Set[any.CompilationUnit[FT]] = this.compilationUnits, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - classTypeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = this.classTypeLookupMap - ): Project[FT] = ooProject(compilationUnits, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap) - } - - trait CompilationUnit[FT <: FinalTypes] extends any.CompilationUnit[FT] with Factory[FT] { - def classes: Seq[Class[FT]] = Seq.empty - def methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - def constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty - def classTypeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = Map.empty - - def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method[FT], any.Type[FT]]]): any.CompilationUnit[FT] = - copyAsCompilationUnitWithClasses(methodTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.methodTypeLookupMap(tpeRep))) - - def addTypeLookupsForConstructors(lookups: TypeRep => Option[Generator[oo.Constructor[FT], any.Type[FT]]]): any.CompilationUnit[FT] = - copyAsCompilationUnitWithClasses(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) - - def addTypeLookupsForClasses(lookups: TypeRep => Option[Generator[oo.Class[FT], any.Type[FT]]]): any.CompilationUnit[FT] = - copyAsCompilationUnitWithClasses(classTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.classTypeLookupMap(tpeRep))) - - override def initializeInProject(project: any.Project[FT]): any.CompilationUnit[FT] = { - val withLookups = copyAsCompilationUnitWithClasses(classTypeLookupMap = project.classTypeLookupMap, - constructorTypeLookupMap = project.constructorTypeLookupMap, - methodTypeLookupMap = project.methodTypeLookupMap - ) - withLookups.copyAsCompilationUnitWithClasses( - tests = withLookups.tests.map(_.initializeInCompilationUnit(withLookups)) - ) - } - - override def copy( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): any.CompilationUnit[FT] = copyAsCompilationUnitWithClasses(name, imports, tests = tests) - - def copyAsCompilationUnitWithClasses( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - classTypeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = this.classTypeLookupMap, - classes: Seq[Class[FT]] = this.classes, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): CompilationUnit[FT] = ooCompilationUnit(name, imports, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap, classes, tests) - } - - trait Class[FT <: FinalTypes] extends Factory[FT] { - def getSelfClass: finalTypes.Class - - def name: any.Name[FT] - def imports: Seq[any.Import[FT]] = Seq.empty - def parents: Seq[any.Type[FT]] = Seq.empty - def implemented: Seq[any.Type[FT]] = Seq.empty - def fields: Seq[Field[FT]] = Seq.empty - def methods: Seq[any.Method[FT]] = Seq.empty - def constructors: Seq[Constructor[FT]] = Seq.empty - def methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - def constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty - def typeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = Map.empty - def isAbstract: Boolean = false - def isInterface: Boolean = false - def isStatic: Boolean = false - - def toTargetLanguageType(tpe: TypeRep): Generator[Class[FT], any.Type[FT]] = typeLookupMap(tpe) - - def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method[FT], any.Type[FT]]]): oo.Class[FT] = - copy(methodTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.methodTypeLookupMap(tpeRep))) - - def addTypeLookupsForConstructors(lookups: TypeRep => Option[Generator[oo.Constructor[FT], any.Type[FT]]]): oo.Class[FT] = - copy(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) - - def addTypeLookupsForClasses(lookups: TypeRep => Option[Generator[Class[FT], any.Type[FT]]]): oo.Class[FT] = { - copy(typeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.typeLookupMap(tpeRep))) - } - - def addParent(parent: any.Type[FT]): Class[FT] = - copy(parents = (this.parents :+ parent).distinct) - - def addImplemented(impl: any.Type[FT]): Class[FT] = - copy(implemented = (this.implemented :+ impl).distinct) - - def addField(field: Field[FT]): Class[FT] = - copy(fields = this.fields :+ field) // TODO: make distinct by name - - def getField(name: any.Name[FT]): Expression[FT] = - memberAccessExpression(selfReferenceExpression, name) - - def addMethod(method: Method[FT]): Class[FT] = - copy(methods = this.methods :+ method) - - def addConstructor(constructor: Constructor[FT]): Class[FT] = - copy(constructors = this.constructors :+ constructor) - - def resolveImport(tpe: any.Type[FT]): Seq[any.Import[FT]] - def findClass(qualifiedName: any.Name[FT]*): any.Type[FT] - def getFreshName(basedOn: any.Name[FT]): any.Name[FT] - - def copy( - name: any.Name[FT] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - parents: Seq[any.Type[FT]] = this.parents, - implemented: Seq[any.Type[FT]] = this.implemented, - fields: Seq[Field[FT]] = this.fields, - methods: Seq[any.Method[FT]] = this.methods, - constructors: Seq[Constructor[FT]] = this.constructors, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - typeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isInterface: Boolean = this.isInterface, - isStatic: Boolean = this.isStatic, - ): Class[FT] = cls( - name = name, - imports = imports, - parents = parents, - implemented = implemented, - methods = methods, - fields = fields, - constructors = constructors, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - typeLookupMap = typeLookupMap, - isAbstract = isAbstract, - isInterface = isInterface, - isStatic = isStatic, - ) - } - - trait TestSuite[FT <: FinalTypes] extends any.TestSuite[FT] with Factory[FT] { - def underlyingClass: Class[FT] - def testMarkers: Seq[Boolean] - - override def name: any.Name[FT] = underlyingClass.name - override def tests: Seq[any.Method[FT]] = underlyingClass.methods.zip(testMarkers).filter{case (m, isTest) => isTest}.map(_._1) - override def methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = underlyingClass.methodTypeLookupMap - - override def initializeInCompilationUnit(compilationUnit: any.CompilationUnit[FT]): any.TestSuite[FT] = - copyAsClassBasedTestSuite( - underlyingClass = underlyingClass.copy( - constructorTypeLookupMap = compilationUnit.constructorTypeLookupMap, - methodTypeLookupMap = compilationUnit.methodTypeLookupMap, - typeLookupMap = compilationUnit.classTypeLookupMap, - ), - testMarkers - ) - - override def copy( - name: any.Name[FT] = this.name, - tests: Seq[any.Method[FT]] = this.tests, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - ): any.TestSuite[FT] = { - val helpers = underlyingClass.methods.zip(this.testMarkers).filter{case (m, isTest) => !isTest}.map(_._1) - val testMarkers = Seq.fill(helpers.size)(false) ++ Seq.fill(tests.size)(true) - - copyAsClassBasedTestSuite( - underlyingClass = this.underlyingClass.copy( - name = name, - methods = helpers ++ tests, - methodTypeLookupMap = methodTypeLookupMap - ), - testMarkers - ) - } - - def copyAsClassBasedTestSuite( - underlyingClass: Class[FT] = this.underlyingClass, - testMarkers: Seq[Boolean] = this.testMarkers - ): TestSuite[FT] = classBasedTestSuite(underlyingClass, testMarkers) - - } - - trait Method[FT <: FinalTypes] extends any.Method[FT] with Factory[FT] { - def isAbstract: Boolean = false - def isStatic: Boolean = false - def isPublic: Boolean = false - def isOverride: Boolean = false - - def findClass(qualifiedName: any.Name[FT]*): any.Type[FT] - - def addTestExpressions(exprs: Seq[any.Expression[FT]]): any.Method[FT] - - override def copy( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap - ): any.Method[FT] = clsMethod(name, imports, statements, returnType, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) - - def copyAsClsMethod( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isStatic: Boolean = this.isStatic, - isPublic: Boolean = this.isPublic, - isOverride: Boolean = this.isOverride, - ): Method[FT] = clsMethod(name, imports, statements, returnType, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) - } - - trait Expression[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - - } - - trait MemberAccessExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfMemberAccessExpression: finalTypes.MemberAccessExpression - - def owner: any.Expression[FT] - def field: any.Name[FT] - - def copy( - owner: any.Expression[FT] = this.owner, - field: any.Name[FT] = this.field, - ): MemberAccessExpression[FT] = memberAccessExpression(owner = owner, field = field) - } - - trait SelfReferenceExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfSelfReferenceExpression: finalTypes.SelfReferenceExpression - } - - trait SuperReferenceExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfSuperReferenceExpression: finalTypes.SuperReferenceExpression - - def parentType: any.Type[FT] - - def copy( - parentType: any.Type[FT] = this.parentType, - ): SuperReferenceExpression[FT] = superReferenceExpression(parentType) - } - - trait ObjectInstantiationExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfObjectInstantiationExpression: finalTypes. ObjectInstantiationExpression - - def tpe: any.Type[FT] - def constructorArguments: Seq[any.Expression[FT]] - def body: Option[Class[FT]] = Option.empty - - def copy( - tpe: any.Type[FT] = this.tpe, - constructorArguments: Seq[any.Expression[FT]] = this.constructorArguments, - body: Option[Class[FT]] = this.body - ): ObjectInstantiationExpression[FT] = objectInstantiationExpression(tpe, constructorArguments, body) - } - - trait CastExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfCastExpression: finalTypes.CastExpression - - def tpe: any.Type[FT] - def expression: any.Expression[FT] - - def copy( - tpe: any.Type[FT] = this.tpe, - expression: any.Expression[FT] = this.expression - ): CastExpression[FT] = castExpression(tpe, expression) - } - - trait InstanceOfExpression[FT <: FinalTypes] extends Expression[FT] { - def getSelfInstanceOfExpression: finalTypes.InstanceOfExpression - - def tpe: any.Type[FT] - def expression: any.Expression[FT] - - def copy( - tpe: any.Type[FT] = this.tpe, - expression: any.Expression[FT] = this.expression - ): InstanceOfExpression[FT] = instanceOfExpression(tpe, expression) - } - - trait Constructor[FT <: FinalTypes] extends Method[FT] { - def constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty - def getSelfConstructor: finalTypes.Constructor - - override def isAbstract: Boolean = false - override def isOverride: Boolean = false - - def constructedType: Option[any.Type[FT]] = Option.empty - def superInitialization: Option[(any.Type[FT], Seq[any.Expression[FT]])] = Option.empty - def fieldInitializers: Seq[(any.Name[FT], any.Expression[FT])] = Seq.empty - - def addConstructorTypeLookups(lookups: TypeRep => Option[Generator[Constructor[FT], any.Type[FT]]]): Constructor[FT] = { - copyAsConstructor(constructorTypeLookupMap = (tpeRep: TypeRep) => lookups(tpeRep).getOrElse(this.constructorTypeLookupMap(tpeRep))) - } - def toTargetLanguageTypeInConstructor(tpe: TypeRep): Generator[Constructor[FT], any.Type[FT]] = constructorTypeLookupMap(tpe) - - override def copyAsClsMethod( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isStatic: Boolean = this.isStatic, - isPublic: Boolean = this.isPublic, - isOverride: Boolean = this.isOverride, - ): Method[FT] = copyAsConstructor(this.constructedType, imports, statements, parameters, typeLookupMap) - - def copyAsConstructor( - constructedType: Option[any.Type[FT]] = this.constructedType, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT],any.Type[FT]] = this.constructorTypeLookupMap, - superInitialization: Option[(any.Type[FT], Seq[any.Expression[FT]])] = this.superInitialization, - fieldInitializers: Seq[(any.Name[FT], any.Expression[FT])] = this.fieldInitializers, - ): Constructor[FT] = constructor(constructedType, imports, statements, parameters, typeLookupMap, constructorTypeLookupMap, superInitialization, fieldInitializers) - } - - trait Field[FT <: FinalTypes] extends Factory[FT] { - def getSelfField: finalTypes.Field - - def name: any.Name[FT] - def tpe: any.Type[FT] - def init: Option[any.Expression[FT]] = Option.empty - - def copy( - name: any.Name[FT] = this.name, - tpe: any.Type[FT] = this.tpe, - init: Option[any.Expression[FT]] = this.init, - ): Field[FT] = field(name, tpe, init) - } - - trait ClassReferenceType[FT <: FinalTypes] extends any.Type[FT] with Factory[FT] { - def getSelfClassReferenceType: finalTypes.ClassReferenceType - - def qualifiedClassName: Seq[any.Name[FT]] - - def copy( - qualifiedClassName: Seq[any.Name[FT]] = this.qualifiedClassName - ): ClassReferenceType[FT] = classReferenceType(qualifiedClassName:_*) - } - - trait Factory[FT <: FinalTypes] extends any.Factory[FT] { - - override def project(compilationUnits: Set[any.CompilationUnit[FT]]): any.Project[FT] = - ooProject(compilationUnits = compilationUnits, methodTypeLookupMap=Map.empty, constructorTypeLookupMap=Map.empty, classTypeLookupMap=Map.empty) - - - def ooProject( - compilationUnits: Set[any.CompilationUnit[FT]] = Set.empty, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = Map.empty - ): any.Project[FT] - - - override def compilationUnit(name: Seq[any.Name[FT]], imports: Seq[any.Import[FT]], tests: Seq[any.TestSuite[FT]]): any.CompilationUnit[FT] = - ooCompilationUnit(name, imports, methodTypeLookupMap=Map.empty, constructorTypeLookupMap=Map.empty, classTypeLookupMap=Map.empty, classes=Seq.empty, tests = tests) - - def ooCompilationUnit( - name: Seq[any.Name[FT]], - imports: Seq[any.Import[FT]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = Map.empty, - classes: Seq[Class[FT]] = Seq.empty, - tests: Seq[any.TestSuite[FT]] = Seq.empty): CompilationUnit[FT] - - override def method( - name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - ): any.Method[FT] = clsMethod(name, imports, statements, returnType, parameters, typeLookupMap, isAbstract = false, isStatic = false, isPublic = false, isOverride = false) - - def clsMethod( - name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - isAbstract: Boolean = false, - isStatic: Boolean = false, - isPublic: Boolean = false, - isOverride: Boolean = false - ): Method[FT] - - def cls( - name: any.Name[FT], - imports: Seq[any.Import[FT]] = Seq.empty, - parents: Seq[any.Type[FT]] = Seq.empty, - implemented: Seq[any.Type[FT]] = Seq.empty, - fields: Seq[Field[FT]] = Seq.empty, - methods: Seq[any.Method[FT]] = Seq.empty, - constructors: Seq[Constructor[FT]] = Seq.empty, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty, - typeLookupMap: TypeRep => Generator[Class[FT], any.Type[FT]] = Map.empty, - isAbstract: Boolean = false, - isInterface: Boolean = false, - isStatic: Boolean = false, - ): Class[FT] - - def testSuite(name: any.Name[FT], tests: Seq[any.Method[FT]], methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty): TestSuite[FT] = - classBasedTestSuite(cls(name = name, methods = tests, methodTypeLookupMap = methodTypeLookupMap), Seq.fill(tests.size)(true)) - - def classBasedTestSuite(underlyingClass: Class[FT], testMarkers: Seq[Boolean]): TestSuite[FT] - - def constructor( - constructedType: Option[any.Type[FT]] = Option.empty, - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[Constructor[FT], any.Type[FT]] = Map.empty, - superInitialization: Option[(any.Type[FT], Seq[any.Expression[FT]])] = Option.empty, - fieldInitializers: Seq[(any.Name[FT], any.Expression[FT])] = Seq.empty, - ): Constructor[FT] - - def field( - name: any.Name[FT], - tpe: any.Type[FT], - init: Option[any.Expression[FT]] = Option.empty, - ): Field[FT] - - def memberAccessExpression( - owner: any.Expression[FT], - field: any.Name[FT], - ): MemberAccessExpression[FT] - - def objectInstantiationExpression( - tpe: any.Type[FT], - constructorArguments: Seq[any.Expression[FT]], - body: Option[Class[FT]] = Option.empty - ): ObjectInstantiationExpression[FT] - - def castExpression( - tpe: any.Type[FT], - expression: any.Expression[FT] - ): CastExpression[FT] - - def instanceOfExpression( - tpe: any.Type[FT], - expression: any.Expression[FT] - ): InstanceOfExpression[FT] - - def superReferenceExpression( - parentType: any.Type[FT] - ): SuperReferenceExpression[FT] - - def selfReferenceExpression: SelfReferenceExpression[FT] - - def classReferenceType(qualifiedClassName: any.Name[FT]*): ClassReferenceType[FT] - - implicit def convert(other: any.Project[FT]): Project[FT] - implicit def convert(other: any.CompilationUnit[FT]): CompilationUnit[FT] - implicit def convert(other: any.Method[FT]): Method[FT] - implicit def convert(other: any.TestSuite[FT]): TestSuite[FT] - implicit def convert(other: Class[FT]): Class[FT] - implicit def convert(other: Constructor[FT]): Constructor[FT] - implicit def convert(other: Field[FT]): Field[FT] - implicit def convert(other: MemberAccessExpression[FT]): MemberAccessExpression[FT] - implicit def convert(other: SelfReferenceExpression[FT]): SelfReferenceExpression[FT] - implicit def convert(other: ObjectInstantiationExpression[FT]): ObjectInstantiationExpression[FT] - implicit def convert(other: CastExpression[FT]): CastExpression[FT] - implicit def convert(other: InstanceOfExpression[FT]): InstanceOfExpression[FT] - implicit def convert(other: SuperReferenceExpression[FT]): SuperReferenceExpression[FT] - implicit def convert(other: ClassReferenceType[FT]): ClassReferenceType[FT] - } - -} \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphism.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphism.scala index 70ed44ae..f6f4ade3 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphism.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphism.scala @@ -1,53 +1,54 @@ -package org.combinators.ep.language.inbetween.polymorphism /*DI:LI:AI*/ +package org.combinators.ep.language.inbetween.polymorphism +/*DI:LI:AI*/ -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{AddTypeParameter, Apply, GetTypeArguments, ParametricPolymorphism => PP} + +import org.combinators.cogen.paradigm.{AddTypeParameter, Apply, GetTypeArguments, ParametricPolymorphism as PP} +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.inbetween.any.AnyParadigm import org.combinators.ep.language.inbetween.any -trait ParametricPolymorphism[FT <: FinalTypes, FactoryType <: Factory[FT]] extends PP { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.{FT=>_, _} - import syntax._ - lazy val factory: base.factory.type = base.factory - override type TypeParameterContext = TypeParameter[FT] +trait ParametricPolymorphism[AST <: ParametricPolymorphismAST, B](val base: AnyParadigm.WithAST[AST] & B) extends PP { + import base.ast.factory + import base.ast.polymorphismFactory + import base.ast.polymorphism.* + import base.ast.any + override type TypeParameterContext = TypeParameter + override val methodBodyCapabilities: MethodBodyCapabilities = new MethodBodyCapabilities { - override implicit val canAddTypeParameterInMethod: Understands[any.Method[FT], AddTypeParameter[any.Name[FT], TypeParameterContext]] = - new Understands[any.Method[FT], AddTypeParameter[any.Name[FT], TypeParameterContext]] { - override def perform(context: any.Method[FT], command: AddTypeParameter[any.Name[FT], TypeParameter[FT]]): (any.Method[FT], Unit) = { - val emptyTypeParam = factory.typeParameter(command.name) + override implicit val canAddTypeParameterInMethod: Understands[any.Method, AddTypeParameter[any.Name, TypeParameterContext]] = + new Understands[any.Method, AddTypeParameter[any.Name, TypeParameterContext]] { + override def perform(context: any.Method, command: AddTypeParameter[any.Name, TypeParameter]): (any.Method, Unit) = { + val emptyTypeParam = polymorphismFactory.typeParameter(command.name) val (tpeParam, _) = Command.runGenerator(command.spec, emptyTypeParam) val currentMethod = factory.convert(context) val withTypeParameter = currentMethod.copyAsTypeParamMethod(typeParameters = currentMethod.typeParameters :+ tpeParam) (withTypeParameter, ()) } } - override implicit val canGetTypeArgumentsInMethod: Understands[any.Method[FT], GetTypeArguments[any.Type[FT]]] = - new Understands[any.Method[FT], GetTypeArguments[any.Type[FT]]] { - override def perform(context: any.Method[FT], command: GetTypeArguments[any.Type[FT]]): (any.Method[FT], Seq[any.Type[FT]]) = { + override implicit val canGetTypeArgumentsInMethod: Understands[any.Method, GetTypeArguments[any.Type]] = + new Understands[any.Method, GetTypeArguments[any.Type]] { + override def perform(context: any.Method, command: GetTypeArguments[any.Type]): (any.Method, Seq[any.Type]) = { (context, factory.convert(context).typeParameters.map(_.toTypeArgument)) } } - override implicit val canApplyTypeInMethod: Understands[any.Method[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] = - new Understands[any.Method[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] { - override def perform(context: any.Method[FT], command: Apply[any.Type[FT], any.Type[FT], any.Type[FT]]): (any.Method[FT], any.Type[FT]) = { - (context, factory.typeApplication(command.functional, command.arguments)) + override implicit val canApplyTypeInMethod: Understands[any.Method, Apply[any.Type, any.Type, any.Type]] = + new Understands[any.Method, Apply[any.Type, any.Type, any.Type]] { + override def perform(context: any.Method, command: Apply[any.Type, any.Type, any.Type]): (any.Method, any.Type) = { + (context, polymorphismFactory.typeApplication(command.functional, command.arguments)) } } - override implicit val canApplyMethodToTypeInMethod: Understands[any.Method[FT], Apply[any.Expression[FT], any.Type[FT], any.Expression[FT]]] = - new Understands[any.Method[FT], Apply[any.Expression[FT], any.Type[FT], any.Expression[FT]]] { - override def perform(context: any.Method[FT], command: Apply[any.Expression[FT], any.Type[FT], any.Expression[FT]]): (any.Method[FT], any.Expression[FT]) = { - (context, factory.applyExpression(command.functional, command.arguments.map(factory.typeReferenceExpression))) + override implicit val canApplyMethodToTypeInMethod: Understands[any.Method, Apply[any.Expression, any.Type, any.Expression]] = + new Understands[any.Method, Apply[any.Expression, any.Type, any.Expression]] { + override def perform(context: any.Method, command: Apply[any.Expression, any.Type, any.Expression]): (any.Method, any.Expression) = { + (context, factory.applyExpression(command.functional, command.arguments.map(polymorphismFactory.typeReferenceExpression))) } } } } object ParametricPolymorphism { - type WithBase[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]] = ParametricPolymorphism[FT, FactoryType] { val base: B } - def apply[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B): WithBase[FT, FactoryType, _base.type] = new ParametricPolymorphism[FT, FactoryType] { - val base: _base.type = _base - } + type WithBase[AST <: ParametricPolymorphismAST, B <: AnyParadigm.WithAST[AST]] = ParametricPolymorphism[AST, B] {} + def apply[AST <: ParametricPolymorphismAST, B <: AnyParadigm.WithAST[AST]](_base: B): WithBase[AST, B] = new ParametricPolymorphism[AST, B](_base) {} } \ No newline at end of file diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismAST.scala new file mode 100644 index 00000000..421ffb55 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismAST.scala @@ -0,0 +1,131 @@ +package org.combinators.ep.language.inbetween.polymorphism + +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.TypeRep +import org.combinators.ep.language.inbetween.any.AnyAST + +trait ParametricPolymorphismAST extends AnyAST { + object polymorphism { + object anyOverrides { + trait FinalTypes extends any.FinalTypes { + type Method <: anyOverrides.Method + } + + trait Method extends any.Method { + def typeParameters: Seq[TypeParameter] + + override def copy( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap + ): any.Method = + copyAsTypeParamMethod( + name = name, + imports = imports, + statements = statements, + returnType = returnType, + parameters = parameters, + typeLookupMap = typeLookupMap) + + def copyAsTypeParamMethod( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + typeParameters: Seq[TypeParameter] = this.typeParameters, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap + ): Method = + polymorphismFactory.typeParamMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap) + } + + trait Factory extends any.Factory { + override def method( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + ): any.Method = polymorphismFactory.typeParamMethod(name, imports, statements, returnType, Seq.empty, parameters, typeLookupMap) + } + } + + trait FinalTypes { + type TypeReferenceExpression <: polymorphism.TypeReferenceExpression + type TypeParameter <: polymorphism.TypeParameter + type TypeArgument <: polymorphism.TypeArgument + type TypeApplication <: polymorphism.TypeApplication + } + + trait TypeParameter { + def getSelfTypeParameter: polymorphismFinalTypes.TypeParameter + + def name: any.Name + + def toTypeArgument: TypeArgument = polymorphismFactory.typeArgument(name) + def copy(name: any.Name): TypeParameter = polymorphismFactory.typeParameter(name) + } + + trait TypeArgument extends any.Type { + def getSelfTypeArgument: polymorphismFinalTypes.TypeArgument + def name: any.Name + def copy(name: any.Name): TypeArgument = polymorphismFactory.typeArgument(name) + } + + trait TypeApplication extends any.Type { + def getSelfTypeApplication: polymorphismFinalTypes.TypeApplication + + def function: any.Type + + def arguments: Seq[any.Type] + + def copy( + function: any.Type = this.function, + arguments: Seq[any.Type] = this.arguments + ): TypeApplication = polymorphismFactory.typeApplication(function, arguments) + + } + + + + trait TypeReferenceExpression extends any.Expression { + def getSelfTypeReferenceExpression: polymorphismFinalTypes.TypeReferenceExpression + + def tpe: any.Type + + def copy( + tpe: any.Type = this.tpe + ): TypeReferenceExpression = polymorphismFactory.typeReferenceExpression(tpe) + } + + trait Factory { + def typeParameter(name: any.Name): TypeParameter + def typeArgument(name: any.Name): TypeArgument + def typeApplication(function: any.Type, arguments: Seq[any.Type]): TypeApplication + def typeParamMethod( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + typeParameters: Seq[TypeParameter] = Seq.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + ): anyOverrides.Method + def typeReferenceExpression(tpe: any.Type): TypeReferenceExpression + + implicit def convert(other: TypeReferenceExpression): polymorphismFinalTypes.TypeReferenceExpression = other.getSelfTypeReferenceExpression + implicit def convert(other: TypeParameter): polymorphismFinalTypes.TypeParameter = other.getSelfTypeParameter + implicit def convert(other: TypeArgument): polymorphismFinalTypes.TypeArgument = other.getSelfTypeArgument + implicit def convert(other: TypeApplication): polymorphismFinalTypes.TypeApplication = other.getSelfTypeApplication + } + } + + val finalTypes: polymorphism.anyOverrides.FinalTypes + val polymorphismFinalTypes: polymorphism.FinalTypes + val factory: polymorphism.anyOverrides.Factory + val polymorphismFactory: polymorphism.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismInADTContexts.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismInADTContexts.scala index 1dd90123..19dc26c3 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismInADTContexts.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/ParametricPolymorphismInADTContexts.scala @@ -1,35 +1,25 @@ package org.combinators.ep.language.inbetween.polymorphism -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{Apply, ParametricPolymorphismInADTContexts => PPADT} +import org.combinators.cogen.paradigm.{Apply, ParametricPolymorphismInADTContexts as PPADT} +import org.combinators.cogen.Understands import org.combinators.ep.language.inbetween.any.AnyParadigm -import org.combinators.ep.language.inbetween.{any, functional => fun} -import org.combinators.ep.language.inbetween.functional.FunctionalParadigm +import org.combinators.ep.language.inbetween.functional.{FunctionalAST, FunctionalParadigm} - - -trait ParametricPolymorphismInADTContexts[FT <: FinalTypes with fun.FinalTypes, FactoryType <: Factory[FT] with fun.Factory[FT]] extends PPADT { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.{FT=>_, FactoryType=>_, _} - import syntax._ - - val functional: FunctionalParadigm.WithBase[FT, FactoryType, base.type] - lazy val factory: base.factory.type = base.factory +trait ParametricPolymorphismInADTContexts[AST <: ParametricPolymorphismAST & FunctionalAST, B, F](val base: AnyParadigm.WithAST[AST] & B, val functional: FunctionalParadigm.WithBase[AST, base.type & B] & F) extends PPADT { + import base.ast.any + import base.ast.polymorphismFactory override val algebraicDataTypeCapabilities: AlgebraicDataTypeCapabilities = new AlgebraicDataTypeCapabilities { - implicit val canApplyTypeInADT: Understands[fun.AlgebraicDataType[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] = new Understands[fun.AlgebraicDataType[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] { - def perform(context: fun.AlgebraicDataType[FT], command: Apply[any.Type[FT], any.Type[FT], any.Type[FT]]): (fun.AlgebraicDataType[FT], any.Type[FT]) = { - (context, factory.typeApplication(command.functional, command.arguments)) + implicit val canApplyTypeInADT: Understands[functional.TypeContext, Apply[any.Type, any.Type, any.Type]] = new Understands[functional.TypeContext, Apply[any.Type, any.Type, any.Type]] { + def perform(context: functional.TypeContext, command: Apply[any.Type, any.Type, any.Type]): (functional.TypeContext, any.Type) = { + (context, polymorphismFactory.typeApplication(command.functional, command.arguments)) } } } } object ParametricPolymorphismInADTContexts { - type WithBase[FT <: FinalTypes with fun.FinalTypes, FactoryType <: Factory[FT] with fun.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType], F <: FunctionalParadigm.WithBase[FT, FactoryType, B]] = - ParametricPolymorphismInADTContexts[FT, FactoryType] { val base: B; val functional: F } - def apply[FT <: FinalTypes with fun.FinalTypes, FactoryType <: Factory[FT] with fun.Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B)(_functional: FunctionalParadigm.WithBase[FT, FactoryType, _base.type]): WithBase[FT, FactoryType, _base.type, _functional.type] = new ParametricPolymorphismInADTContexts[FT, FactoryType] { - val base: _base.type = _base - val functional: _functional.type = _functional - } + type WithBase[AST <: ParametricPolymorphismAST & FunctionalAST, B <: AnyParadigm.WithAST[AST], F <: FunctionalParadigm.WithBase[AST, B]] = ParametricPolymorphismInADTContexts[AST, B, F] {} + + def apply[AST <: ParametricPolymorphismAST & FunctionalAST, B <: AnyParadigm.WithAST[AST], F <: FunctionalParadigm.WithBase[AST, B]](_base: B, _functional: FunctionalParadigm.WithBase[AST, _base.type] & F): WithBase[AST, B, F] = new ParametricPolymorphismInADTContexts[AST, B, F](_base, _functional) {} } diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/Generics.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/Generics.scala index 4d4f4275..e5dfea95 100644 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/Generics.scala +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/Generics.scala @@ -1,95 +1,89 @@ package org.combinators.ep.language.inbetween.polymorphism.generics /*DI:LI:AI*/ -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.ParametricPolymorphism.WithBase -import org.combinators.ep.generator.paradigm.{AddLowerBound, AddTypeParameter, AddUpperBound, Apply, GetCurrentTypeParameter, GetTypeArguments, AnyParadigm => AP, Generics => GS, ObjectOriented => OO, ParametricPolymorphism => PP} -import org.combinators.ep.language.inbetween.{any, oo, polymorphism} +import org.combinators.cogen.paradigm.{AddLowerBound, AddTypeParameter, AddUpperBound, Apply, GetCurrentTypeParameter, GetTypeArguments, AnyParadigm as AP, Generics as GS, ObjectOriented as OO, ParametricPolymorphism as PP} +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.paradigm.ParametricPolymorphism.WithBase import org.combinators.ep.language.inbetween.any.AnyParadigm import org.combinators.ep.language.inbetween.oo.OOParadigm import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphism -trait Generics[FT <: FinalTypes, FactoryType <: Factory[FT]] extends GS { - val base: AnyParadigm.WithFT[FT, FactoryType] - import base.{FT=>_, FactoryType=>_, _} - import syntax._ - val ooParadigm: OOParadigm.WithBase[FT, FactoryType, base.type] - val ppolyParadigm: ParametricPolymorphism.WithBase[FT, FactoryType, base.type] - lazy val factory: base.factory.type = base.factory +trait Generics[AST <: GenericsAST, B, OO, PP](val base: AnyParadigm.WithAST[AST] & B, override val ooParadigm: OOParadigm.WithBase[AST, base.type] & OO, override val ppolyParadigm: ParametricPolymorphism.WithBase[AST, base.type] & PP) extends GS { + import base.ast.factory + import base.ast.polymorphismFactory + import base.ast.ooFactory + import base.ast.any + import base.ast.polymorphism as pp + import base.ast.oo + override val classCapabilities: ClassCapabilities = new ClassCapabilities { - override implicit val canAddTypeParameterInClass: Understands[oo.Class[FT], AddTypeParameter[any.Name[FT], polymorphism.TypeParameter[FT]]] = - new Understands[oo.Class[FT], AddTypeParameter[any.Name[FT], polymorphism.TypeParameter[FT]]] { - override def perform(context: oo.Class[FT], command: AddTypeParameter[any.Name[FT], polymorphism.TypeParameter[FT]]): (oo.Class[FT], Unit) = { - val emptyTypeParam = factory.typeParameter(command.name) + override implicit val canAddTypeParameterInClass: Understands[oo.Class, AddTypeParameter[any.Name, pp.TypeParameter]] = + new Understands[oo.Class, AddTypeParameter[any.Name, pp.TypeParameter]] { + override def perform(context: oo.Class, command: AddTypeParameter[any.Name, pp.TypeParameter]): (oo.Class, Unit) = { + val emptyTypeParam = polymorphismFactory.typeParameter(command.name) val (tpeParam, _) = Command.runGenerator(command.spec, emptyTypeParam) - val genericClass = factory.convert(context) + val genericClass = ooFactory.convert(context) (genericClass.copyAsGenericClass(typeParameters = genericClass.typeParameters :+ tpeParam), ()) } } - override implicit val canGetTypeArgumentsInClass: Understands[oo.Class[FT], GetTypeArguments[any.Type[FT]]] = - new Understands[oo.Class[FT], GetTypeArguments[any.Type[FT]]] { - override def perform(context: oo.Class[FT], command: GetTypeArguments[any.Type[FT]]): (oo.Class[FT], Seq[any.Type[FT]]) = { - val genericClass = factory.convert(context) + override implicit val canGetTypeArgumentsInClass: Understands[oo.Class, GetTypeArguments[any.Type]] = + new Understands[oo.Class, GetTypeArguments[any.Type]] { + override def perform(context: oo.Class, command: GetTypeArguments[any.Type]): (oo.Class, Seq[any.Type]) = { + val genericClass = ooFactory.convert(context) (context, genericClass.typeParameters.map(_.toTypeArgument)) } } - override implicit val canApplyTypeInClass: Understands[oo.Class[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] = - new Understands[oo.Class[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] { - override def perform(context: oo.Class[FT], command: Apply[any.Type[FT], any.Type[FT], any.Type[FT]]): (oo.Class[FT], any.Type[FT]) = { - (context, factory.typeApplication(command.functional, command.arguments)) + override implicit val canApplyTypeInClass: Understands[oo.Class, Apply[any.Type, any.Type, any.Type]] = + new Understands[oo.Class, Apply[any.Type, any.Type, any.Type]] { + override def perform(context: oo.Class, command: Apply[any.Type, any.Type, any.Type]): (oo.Class, any.Type) = { + (context, polymorphismFactory.typeApplication(command.functional, command.arguments)) } } } override val typeParameterCapabilities: TypeParameterCapabilities = new TypeParameterCapabilities { - override implicit val canGetCurrentTypeParameter: Understands[ppolyParadigm.TypeParameterContext, GetCurrentTypeParameter[any.Type[FT]]] = - new Understands[ppolyParadigm.TypeParameterContext, GetCurrentTypeParameter[any.Type[FT]]] { - override def perform(context: ppolyParadigm.TypeParameterContext, command: GetCurrentTypeParameter[any.Type[FT]]): (ppolyParadigm.TypeParameterContext, any.Type[FT]) = { + override implicit val canGetCurrentTypeParameter: Understands[ppolyParadigm.TypeParameterContext, GetCurrentTypeParameter[any.Type]] = + new Understands[ppolyParadigm.TypeParameterContext, GetCurrentTypeParameter[any.Type]] { + override def perform(context: ppolyParadigm.TypeParameterContext, command: GetCurrentTypeParameter[any.Type]): (ppolyParadigm.TypeParameterContext, any.Type) = { (context, context.toTypeArgument) } } - override implicit val canAddUpperBoundInTypeParameter: Understands[ppolyParadigm.TypeParameterContext, AddUpperBound[any.Type[FT]]] = - new Understands[ppolyParadigm.TypeParameterContext, AddUpperBound[any.Type[FT]]] { - override def perform(context: polymorphism.TypeParameter[FT], command: AddUpperBound[any.Type[FT]]): (polymorphism.TypeParameter[FT], Unit) = { - val genericTypeParam = factory.convert(context) + override implicit val canAddUpperBoundInTypeParameter: Understands[ppolyParadigm.TypeParameterContext, AddUpperBound[any.Type]] = + new Understands[ppolyParadigm.TypeParameterContext, AddUpperBound[any.Type]] { + override def perform(context: pp.TypeParameter, command: AddUpperBound[any.Type]): (pp.TypeParameter, Unit) = { + val genericTypeParam = polymorphismFactory.convert(context) (genericTypeParam.copyAsTypeParameterWithBounds(upperBounds = genericTypeParam.upperBounds :+ command.bound), ()) } } - override implicit val canAddLowerBoundInTypeParameter: Understands[ppolyParadigm.TypeParameterContext, AddLowerBound[any.Type[FT]]] = - new Understands[ppolyParadigm.TypeParameterContext, AddLowerBound[any.Type[FT]]] { - override def perform(context: polymorphism.TypeParameter[FT], command: AddLowerBound[any.Type[FT]]): (polymorphism.TypeParameter[FT], Unit) = { - val genericTypeParam = factory.convert(context) + override implicit val canAddLowerBoundInTypeParameter: Understands[ppolyParadigm.TypeParameterContext, AddLowerBound[any.Type]] = + new Understands[ppolyParadigm.TypeParameterContext, AddLowerBound[any.Type]] { + override def perform(context: pp.TypeParameter, command: AddLowerBound[any.Type]): (pp.TypeParameter, Unit) = { + val genericTypeParam = polymorphismFactory.convert(context) (genericTypeParam.copyAsTypeParameterWithBounds(lowerBounds = genericTypeParam.lowerBounds :+ command.bound), ()) } } - override implicit val canApplyTypeTypeParameter: Understands[ppolyParadigm.TypeParameterContext, Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] = - new Understands[ppolyParadigm.TypeParameterContext, Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] { - override def perform(context: ppolyParadigm.TypeParameterContext, command: Apply[any.Type[FT], any.Type[FT], any.Type[FT]]): (ppolyParadigm.TypeParameterContext, any.Type[FT]) = { - (context, factory.typeApplication(command.functional, command.arguments)) + override implicit val canApplyTypeTypeParameter: Understands[ppolyParadigm.TypeParameterContext, Apply[any.Type, any.Type, any.Type]] = + new Understands[ppolyParadigm.TypeParameterContext, Apply[any.Type, any.Type, any.Type]] { + override def perform(context: ppolyParadigm.TypeParameterContext, command: Apply[any.Type, any.Type, any.Type]): (ppolyParadigm.TypeParameterContext, any.Type) = { + (context, polymorphismFactory.typeApplication(command.functional, command.arguments)) } } } override val constructorCapabilities: ConstructorCapabilities = new ConstructorCapabilities { - override implicit val canApplyTypeInConstructor: Understands[oo.Constructor[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] = - new Understands[oo.Constructor[FT], Apply[any.Type[FT], any.Type[FT], any.Type[FT]]] { - override def perform(context: oo.Constructor[FT], command: Apply[any.Type[FT], any.Type[FT], any.Type[FT]]): (oo.Constructor[FT], any.Type[FT]) = { - (context, factory.typeApplication(command.functional, command.arguments)) + override implicit val canApplyTypeInConstructor: Understands[oo.Constructor, Apply[any.Type, any.Type, any.Type]] = + new Understands[oo.Constructor, Apply[any.Type, any.Type, any.Type]] { + override def perform(context: oo.Constructor, command: Apply[any.Type, any.Type, any.Type]): (oo.Constructor, any.Type) = { + (context, polymorphismFactory.typeApplication(command.functional, command.arguments)) } } - override implicit val canApplyMethodToTypeInConstructor: Understands[oo.Constructor[FT], Apply[any.Expression[FT], any.Type[FT], any.Expression[FT]]] = - new Understands[oo.Constructor[FT], Apply[any.Expression[FT], any.Type[FT], any.Expression[FT]]] { - override def perform(context: oo.Constructor[FT], command: Apply[any.Expression[FT], any.Type[FT], any.Expression[FT]]): (oo.Constructor[FT], any.Expression[FT]) = { - (context, factory.applyExpression(command.functional, command.arguments.map(factory.typeReferenceExpression))) + override implicit val canApplyMethodToTypeInConstructor: Understands[oo.Constructor, Apply[any.Expression, any.Type, any.Expression]] = + new Understands[oo.Constructor, Apply[any.Expression, any.Type, any.Expression]] { + override def perform(context: oo.Constructor, command: Apply[any.Expression, any.Type, any.Expression]): (oo.Constructor, any.Expression) = { + (context, factory.applyExpression(command.functional, command.arguments.map(polymorphismFactory.typeReferenceExpression))) } } } } object Generics { - type WithBase[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType], OO <: OOParadigm.WithBase[FT, FactoryType, B], PP <: ParametricPolymorphism.WithBase[FT, FactoryType, B]] = - Generics[FT, FactoryType] { val base: B; val ooParadigm: OO; val ppolyParadigm: PP } - def apply[FT <: FinalTypes, FactoryType <: Factory[FT], B <: AnyParadigm.WithFT[FT, FactoryType]](_base: B)(oo: OOParadigm.WithBase[FT, FactoryType, _base.type], pp: ParametricPolymorphism.WithBase[FT, FactoryType, _base.type]): WithBase[FT, FactoryType, _base.type, oo.type, pp.type] = - new Generics[FT, FactoryType] { - val base: _base.type = _base - val ooParadigm: oo.type = oo - val ppolyParadigm: pp.type = pp - } -} \ No newline at end of file + type WithBase[AST <: GenericsAST, B <: AnyParadigm.WithAST[AST], OO <: OOParadigm.WithBase[AST, B], PP <: ParametricPolymorphism.WithBase[AST, B]] = Generics[AST, B, OO, PP] {} + def apply[AST <: GenericsAST, B <: AnyParadigm.WithAST[AST], OO <: OOParadigm.WithBase[AST, B], PP <: ParametricPolymorphism.WithBase[AST, B]](_base: B, _ooParadigm: OO & OOParadigm.WithBase[AST, _base.type], _ppolyParadigm: PP & ParametricPolymorphism.WithBase[AST, _base.type]): WithBase[AST, B, OO, PP] = new Generics[AST, B, OO, PP](_base, _ooParadigm, _ppolyParadigm) {} +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/GenericsAST.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/GenericsAST.scala new file mode 100644 index 00000000..30aca379 --- /dev/null +++ b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/GenericsAST.scala @@ -0,0 +1,290 @@ +package org.combinators.ep.language.inbetween.polymorphism.generics + +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.TypeRep +import org.combinators.ep.language.inbetween.oo.OOAST +import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphismAST + +trait GenericsAST extends ParametricPolymorphismAST with OOAST { + object generics { + object anyOverrides { + trait FinalTypes extends oo.anyOverrides.FinalTypes with polymorphism.anyOverrides.FinalTypes { + type Method <: anyOverrides.Method + } + + trait Method extends polymorphism.anyOverrides.Method with oo.anyOverrides.Method { + override def copy( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap + ): any.Method = + copyAsGenericMethod( + name = name, + imports = imports, + statements = statements, + returnType = returnType, + parameters = parameters, + typeLookupMap = typeLookupMap) + + override def copyAsTypeParamMethod( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + typeParameters: Seq[polymorphism.TypeParameter] = this.typeParameters, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap + ): polymorphism.anyOverrides.Method = + copyAsGenericMethod( + name = name, + imports = imports, + statements = statements, + returnType = returnType, + typeParameters = typeParameters, + parameters = parameters, + typeLookupMap = typeLookupMap) + + override def copyAsClsMethod( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isStatic: Boolean = this.isStatic, + isPublic: Boolean = this.isPublic, + isOverride: Boolean = this.isOverride + ): oo.anyOverrides.Method = + copyAsGenericMethod(name = name, + imports = imports, + statements = statements, + returnType = returnType, + parameters = parameters, + typeLookupMap = typeLookupMap, + isAbstract = isAbstract, + isStatic = isStatic, + isPublic = isPublic, + isOverride = isOverride) + + def copyAsGenericMethod( + name: any.Name = this.name, + imports: Set[any.Import] = this.imports, + statements: Seq[any.Statement] = this.statements, + returnType: Option[any.Type] = this.returnType, + typeParameters: Seq[polymorphism.TypeParameter] = this.typeParameters, + parameters: Seq[(any.Name, any.Type)] = this.parameters, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isStatic: Boolean = this.isStatic, + isPublic: Boolean = this.isPublic, + isOverride: Boolean = this.isOverride, + ): Method = + genericsFactory.genericMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) + } + + trait Factory extends oo.anyOverrides.Factory with polymorphism.anyOverrides.Factory { + } + } + object ooOverrides { + trait FinalTypes extends oo.FinalTypes { + type Class <: ooOverrides.Class + } + + trait Class extends oo.Class { + def typeParameters: Seq[polymorphism.TypeParameter] + + override def copy( + name: any.Name = this.name, + imports: Seq[any.Import] = this.imports, + parents: Seq[any.Type] = this.parents, + implemented: Seq[any.Type] = this.implemented, + fields: Seq[oo.Field] = this.fields, + methods: Seq[any.Method] = this.methods, + constructors: Seq[oo.Constructor] = this.constructors, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = this.constructorTypeLookupMap, + typeLookupMap: TypeRep => Generator[oo.Class, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isInterface: Boolean = this.isInterface, + isStatic: Boolean = this.isStatic, + ): oo.Class = copyAsGenericClass( + name = name, + imports = imports, + parents = parents, + implemented = implemented, + fields = fields, + methods = methods, + constructors = constructors, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + typeLookupMap = typeLookupMap, + isAbstract = isAbstract, + isInterface = isInterface, + isStatic = isStatic, + ) + + def copyAsGenericClass( + name: any.Name = this.name, + imports: Seq[any.Import] = this.imports, + typeParameters: Seq[polymorphism.TypeParameter] = this.typeParameters, + parents: Seq[any.Type] = this.parents, + implemented: Seq[any.Type] = this.implemented, + fields: Seq[oo.Field] = this.fields, + methods: Seq[any.Method] = this.methods, + constructors: Seq[oo.Constructor] = this.constructors, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = this.constructorTypeLookupMap, + typeLookupMap: TypeRep => Generator[oo.Class, any.Type] = this.typeLookupMap, + isAbstract: Boolean = this.isAbstract, + isInterface: Boolean = this.isInterface, + isStatic: Boolean = this.isStatic, + ): oo.Class = genericsFactory.genericClass( + name = name, + imports = imports, + typeParameters = typeParameters, + parents = parents, + implemented = implemented, + fields = fields, + methods = methods, + constructors = constructors, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + typeLookupMap = typeLookupMap, + isAbstract = isAbstract, + isInterface = isInterface, + isStatic = isStatic, + ) + } + + trait Factory extends oo.Factory { + override def cls( + name: any.Name, + imports: Seq[any.Import] = Seq.empty, + parents: Seq[any.Type] = Seq.empty, + implemented: Seq[any.Type] = Seq.empty, + fields: Seq[oo.Field] = Seq.empty, + methods: Seq[any.Method] = Seq.empty, + constructors: Seq[oo.Constructor] = Seq.empty, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = Map.empty, + typeLookupMap: TypeRep => Generator[oo.Class, any.Type] = Map.empty, + isAbstract: Boolean = false, + isInterface: Boolean = false, + isStatic: Boolean = false, + ): oo.Class = + genericsFactory.genericClass( + name, + imports, + Seq.empty, + parents, + implemented, + fields, + methods, + constructors, + methodTypeLookupMap, + constructorTypeLookupMap, + typeLookupMap, + isAbstract, + isInterface, + isStatic, + ) + override def clsMethod( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + isAbstract: Boolean = false, + isStatic: Boolean = false, + isPublic: Boolean = false, + isOverride: Boolean = false + ): oo.anyOverrides.Method = + genericsFactory.genericMethod(name, imports, statements, returnType, Seq.empty, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) + + } + + } + + object polymorphismOverrides { + trait FinalTypes extends polymorphism.FinalTypes { + type TypeParameter <: polymorphismOverrides.TypeParameter + } + + trait TypeParameter extends polymorphism.TypeParameter { + def upperBounds: Seq[any.Type] + def lowerBounds: Seq[any.Type] + + override def copy(name: any.Name = this.name): polymorphism.TypeParameter = copyAsTypeParameterWithBounds(name) + def copyAsTypeParameterWithBounds( + name: any.Name = this.name, + upperBounds: Seq[any.Type] = this.upperBounds, + lowerBounds: Seq[any.Type] = this.lowerBounds + ): TypeParameter = + genericsFactory.typeParameterWithBounds(name, upperBounds, lowerBounds) + } + + trait Factory extends polymorphism.Factory { + override def typeParamMethod( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + typeParameters: Seq[polymorphism.TypeParameter] = Seq.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty + ): polymorphism.anyOverrides.Method = + genericsFactory.genericMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap) + override def typeParameter(name: any.Name): polymorphism.TypeParameter = genericsFactory.typeParameterWithBounds(name) + } + } + + trait Factory { + def genericClass( + name: any.Name, + imports: Seq[any.Import] = Seq.empty, + typeParameters: Seq[polymorphism.TypeParameter] = Seq.empty, + parents: Seq[any.Type] = Seq.empty, + implemented: Seq[any.Type] = Seq.empty, + fields: Seq[oo.Field] = Seq.empty, + methods: Seq[any.Method] = Seq.empty, + constructors: Seq[oo.Constructor] = Seq.empty, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = Map.empty, + typeLookupMap: TypeRep => Generator[oo.Class, any.Type] = Map.empty, + isAbstract: Boolean = false, + isInterface: Boolean = false, + isStatic: Boolean = false, + ): ooOverrides.Class + + def genericMethod( + name: any.Name, + imports: Set[any.Import] = Set.empty, + statements: Seq[any.Statement] = Seq.empty, + returnType: Option[any.Type] = Option.empty, + typeParameters: Seq[polymorphism.TypeParameter] = Seq.empty, + parameters: Seq[(any.Name, any.Type)] = Seq.empty, + typeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + isAbstract: Boolean = false, + isStatic: Boolean = false, + isPublic: Boolean = false, + isOverride: Boolean = false, + ): anyOverrides.Method + + def typeParameterWithBounds(name: any.Name, upperBounds: Seq[any.Type] = Seq.empty, lowerBounds: Seq[any.Type] = Seq.empty): polymorphismOverrides.TypeParameter + } + } + + val finalTypes: generics.anyOverrides.FinalTypes + val ooFinalTypes: generics.ooOverrides.FinalTypes + val polymorphismFinalTypes: generics.polymorphismOverrides.FinalTypes + + val factory: generics.anyOverrides.Factory + val ooFactory: generics.ooOverrides.Factory + val polymorphismFactory: generics.polymorphismOverrides.Factory + val genericsFactory: generics.Factory +} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/package.scala deleted file mode 100644 index cbcb183d..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/generics/package.scala +++ /dev/null @@ -1,258 +0,0 @@ -package org.combinators.ep.language.inbetween.polymorphism /*DI:LI:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.language.inbetween.{any, oo, polymorphism => pp} -import org.combinators.ep.generator.Command.Generator -package object generics { - trait FinalTypes extends pp.FinalTypes with oo.FinalTypes { - - } - - trait TypeParameter[FT <: FinalTypes] extends pp.TypeParameter[FT] with Factory[FT] { - def upperBounds: Seq[any.Type[FT]] - def lowerBounds: Seq[any.Type[FT]] - - override def copy(name: any.Name[FT] = this.name): TypeParameter[FT] = copyAsTypeParameterWithBounds(name) - def copyAsTypeParameterWithBounds( - name: any.Name[FT] = this.name, - upperBounds: Seq[any.Type[FT]] = this.upperBounds, - lowerBounds: Seq[any.Type[FT]] = this.lowerBounds): TypeParameter[FT] = - typeParameterWithBounds(name, upperBounds, lowerBounds) - } - - trait Class[FT <: FinalTypes] extends oo.Class[FT] with Factory[FT] { - def typeParameters: Seq[pp.TypeParameter[FT]] - - override def copy( - name: any.Name[FT] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - parents: Seq[any.Type[FT]] = this.parents, - implemented: Seq[any.Type[FT]] = this.implemented, - fields: Seq[oo.Field[FT]] = this.fields, - methods: Seq[any.Method[FT]] = this.methods, - constructors: Seq[oo.Constructor[FT]] = this.constructors, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - typeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isInterface: Boolean = this.isInterface, - isStatic: Boolean = this.isStatic, - ): oo.Class[FT] = copyAsGenericClass( - name = name, - imports = imports, - parents = parents, - implemented = implemented, - fields = fields, - methods = methods, - constructors = constructors, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - typeLookupMap = typeLookupMap, - isAbstract = isAbstract, - isInterface = isInterface, - isStatic = isStatic, - ) - - def copyAsGenericClass( - name: any.Name[FT] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - typeParameters: Seq[pp.TypeParameter[FT]] = this.typeParameters, - parents: Seq[any.Type[FT]] = this.parents, - implemented: Seq[any.Type[FT]] = this.implemented, - fields: Seq[oo.Field[FT]] = this.fields, - methods: Seq[any.Method[FT]] = this.methods, - constructors: Seq[oo.Constructor[FT]] = this.constructors, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - typeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isInterface: Boolean = this.isInterface, - isStatic: Boolean = this.isStatic, - ): oo.Class[FT] = genericClass( - name = name, - imports = imports, - typeParameters = typeParameters, - parents = parents, - implemented = implemented, - fields = fields, - methods = methods, - constructors = constructors, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - typeLookupMap = typeLookupMap, - isAbstract = isAbstract, - isInterface = isInterface, - isStatic = isStatic, - ) - - } - - trait Method[FT <: FinalTypes] extends pp.Method[FT] with oo.Method[FT] with Factory[FT] { - - - override def copy( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap - ): any.Method[FT] = - copyAsGenericMethod( - name = name, - imports = imports, - statements = statements, - returnType = returnType, - parameters = parameters, - typeLookupMap = typeLookupMap) - - override def copyAsTypeParamMethod(name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - typeParameters: Seq[pp.TypeParameter[FT]] = this.typeParameters, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap): pp.Method[FT] = - copyAsGenericMethod( - name = name, - imports = imports, - statements = statements, - returnType = returnType, - typeParameters = typeParameters, - parameters = parameters, - typeLookupMap = typeLookupMap) - - override def copyAsClsMethod(name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isStatic: Boolean = this.isStatic, - isPublic: Boolean = this.isPublic, - isOverride: Boolean = this.isOverride): oo.Method[FT] = - copyAsGenericMethod(name = name, - imports = imports, - statements = statements, - returnType = returnType, - parameters = parameters, - typeLookupMap = typeLookupMap, - isAbstract = isAbstract, - isStatic = isStatic, - isPublic = isPublic, - isOverride = isOverride) - - def copyAsGenericMethod( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - typeParameters: Seq[pp.TypeParameter[FT]] = this.typeParameters, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap, - isAbstract: Boolean = this.isAbstract, - isStatic: Boolean = this.isStatic, - isPublic: Boolean = this.isPublic, - isOverride: Boolean = this.isOverride, - ) = - genericMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) - } - - trait Factory[FT <: FinalTypes] extends pp.Factory[FT] with oo.Factory[FT] { - - override def cls( - name: any.Name[FT], - imports: Seq[any.Import[FT]] = Seq.empty, - parents: Seq[any.Type[FT]] = Seq.empty, - implemented: Seq[any.Type[FT]] = Seq.empty, - fields: Seq[oo.Field[FT]] = Seq.empty, - methods: Seq[any.Method[FT]] = Seq.empty, - constructors: Seq[oo.Constructor[FT]] = Seq.empty, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = Map.empty, - typeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = Map.empty, - isAbstract: Boolean = false, - isInterface: Boolean = false, - isStatic: Boolean = false, - ): oo.Class[FT] = - genericClass( - name, - imports, - Seq.empty, - parents, - implemented, - fields, - methods, - constructors, - methodTypeLookupMap, - constructorTypeLookupMap, - typeLookupMap, - isAbstract, - isInterface, - isStatic, - ) - - def genericClass( - name: any.Name[FT], - imports: Seq[any.Import[FT]] = Seq.empty, - typeParameters: Seq[pp.TypeParameter[FT]] = Seq.empty, - parents: Seq[any.Type[FT]] = Seq.empty, - implemented: Seq[any.Type[FT]] = Seq.empty, - fields: Seq[oo.Field[FT]] = Seq.empty, - methods: Seq[any.Method[FT]] = Seq.empty, - constructors: Seq[oo.Constructor[FT]] = Seq.empty, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = Map.empty, - typeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = Map.empty, - isAbstract: Boolean = false, - isInterface: Boolean = false, - isStatic: Boolean = false, - ): oo.Class[FT] - - override def clsMethod( - name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - isAbstract: Boolean = false, - isStatic: Boolean = false, - isPublic: Boolean = false, - isOverride: Boolean = false - ): Method[FT] = - genericMethod(name, imports, statements, returnType, Seq.empty, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) - - override def typeParamMethod(name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - typeParameters: Seq[pp.TypeParameter[FT]] = Seq.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty): pp.Method[FT] = - genericMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap) - - def genericMethod( - name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - typeParameters: Seq[pp.TypeParameter[FT]] = Seq.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - isAbstract: Boolean = false, - isStatic: Boolean = false, - isPublic: Boolean = false, - isOverride: Boolean = false, - ): Method[FT] - - override def typeParameter(name: any.Name[FT]): pp.TypeParameter[FT] = typeParameterWithBounds(name) - def typeParameterWithBounds(name: any.Name[FT], upperBounds: Seq[any.Type[FT]] = Seq.empty, lowerBounds: Seq[any.Type[FT]] = Seq.empty): TypeParameter[FT] - - def convert(other: oo.Class[FT]): Class[FT] - def convert(other: any.Method[FT]): Method[FT] - def convert(other: pp.TypeParameter[FT]): TypeParameter[FT] - } - -} diff --git a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/package.scala b/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/package.scala deleted file mode 100644 index 6aeae9b6..00000000 --- a/language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/polymorphism/package.scala +++ /dev/null @@ -1,114 +0,0 @@ -package org.combinators.ep.language.inbetween /*DI:LI:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator - -package object polymorphism { - trait FinalTypes extends any.FinalTypes { - type TypeReferenceExpression <: Expression - type TypeParameter - type TypeArgument <: Type - type TypeApplication <: Type - } - - trait TypeParameter[FT <: FinalTypes] extends Factory[FT] { - def getSelfTypeParameter: finalTypes.TypeParameter - - def name: any.Name[FT] - - def toTypeArgument: TypeArgument[FT] = typeArgument(name) - def copy(name: any.Name[FT]): TypeParameter[FT] = typeParameter(name) - } - - trait TypeArgument[FT <: FinalTypes] extends any.Type[FT] with Factory[FT] { - def getSelfTypeArgument: finalTypes.TypeArgument - def name: any.Name[FT] - def copy(name: any.Name[FT]): TypeArgument[FT] = typeArgument(name) - } - - trait TypeApplication[FT <: FinalTypes] extends any.Type[FT] with Factory[FT] { - def getSelfTypeApplication: finalTypes.TypeApplication - - def function: any.Type[FT] - - def arguments: Seq[any.Type[FT]] - - def copy( - function: any.Type[FT] = this.function, - arguments: Seq[any.Type[FT]] = this.arguments - ): TypeApplication[FT] = typeApplication(function, arguments) - - } - - trait Method[FT <: FinalTypes] extends any.Method[FT] with Factory[FT] { - def typeParameters: Seq[TypeParameter[FT]] - - override def copy( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap - ): any.Method[FT] = - copyAsTypeParamMethod( - name = name, - imports = imports, - statements = statements, - returnType = returnType, - parameters = parameters, - typeLookupMap = typeLookupMap) - - def copyAsTypeParamMethod( - name: any.Name[FT] = this.name, - imports: Set[any.Import[FT]] = this.imports, - statements: Seq[any.Statement[FT]] = this.statements, - returnType: Option[any.Type[FT]] = this.returnType, - typeParameters: Seq[TypeParameter[FT]] = this.typeParameters, - parameters: Seq[(any.Name[FT], any.Type[FT])] = this.parameters, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.typeLookupMap - ): Method[FT] = - typeParamMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap) - } - - trait TypeReferenceExpression[FT <: FinalTypes] extends any.Expression[FT] with Factory[FT] { - def getSelfTypeReferenceExpression: finalTypes.TypeReferenceExpression - - def tpe: any.Type[FT] - - def copy( - tpe: any.Type[FT] = this.tpe - ): TypeReferenceExpression[FT] = typeReferenceExpression(tpe) - } - - trait Factory[FT <: FinalTypes] extends any.Factory[FT] { - def typeParameter(name: any.Name[FT]): TypeParameter[FT] - def typeArgument(name: any.Name[FT]): TypeArgument[FT] - - def typeApplication(function: any.Type[FT], arguments: Seq[any.Type[FT]]): TypeApplication[FT] - override def method( - name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - ): any.Method[FT] = typeParamMethod(name, imports, statements, returnType, Seq.empty, parameters, typeLookupMap) - - def typeParamMethod( - name: any.Name[FT], - imports: Set[any.Import[FT]] = Set.empty, - statements: Seq[any.Statement[FT]] = Seq.empty, - returnType: Option[any.Type[FT]] = Option.empty, - typeParameters: Seq[TypeParameter[FT]] = Seq.empty, - parameters: Seq[(any.Name[FT], any.Type[FT])] = Seq.empty, - typeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty - ): Method[FT] - def typeReferenceExpression(tpe: any.Type[FT]): TypeReferenceExpression[FT] - implicit def convert(other: TypeReferenceExpression[FT]): TypeReferenceExpression[FT] - implicit def convert(other: TypeParameter[FT]): TypeParameter[FT] - implicit def convert(other: TypeArgument[FT]): TypeArgument[FT] - implicit def convert(other: TypeApplication[FT]): TypeApplication[FT] - implicit def convert(other: any.Method[FT]): Method[FT] - } -} diff --git a/language/java/src/main/java/buildTest/Family.java b/language/java/src/main/java/buildTest/Family.java deleted file mode 100644 index 5270279b..00000000 --- a/language/java/src/main/java/buildTest/Family.java +++ /dev/null @@ -1,32 +0,0 @@ -package buildTest; - -import java.util.ArrayList; -import java.util.Iterator; - -public class Family implements Iterable { - - public static final int MAX = 99; // max number of variations for auto generation - - final String prefix; - String[] variations = new String[MAX]; - - public Family (String pre) { - this.prefix = pre; - } - - public void add (int id) { - variations[id] = prefix + id; - } - - /** Return iterator (in reverse order) of successful variations. */ - public Iterator iterator() { - ArrayList ret = new ArrayList<>(); - for (int i = MAX-1; i >= 0; i--) { - if (variations[i] != null) { - ret.add(prefix + i); - } - } - - return ret.iterator(); - } -} diff --git a/language/java/src/main/java/buildTest/README.txt b/language/java/src/main/java/buildTest/README.txt deleted file mode 100644 index ada27153..00000000 --- a/language/java/src/main/java/buildTest/README.txt +++ /dev/null @@ -1,45 +0,0 @@ -To retrieve stats on the individual Scala files, - -DD/I Domain Dependent/Independent -LD/I Language Dependent/Independent -AD/I Approach Dependent/Independent - -Numbers as of 7-9-2018 - -DI:LI:AI 200 -DI:LI:AD 0 -DI:LD:AI 248 -DI:LD:AD 1198 -DD:LI:AI 185 -DD:LI:AD 0 -DD:LD:AI 876 -DD:LD:AD 377 - - -#!/bin/bash - -echo -n "DI:LI:AI " -wc -l `find . -name "*.scala" -exec grep "DI:LI:AI" {} \; -print | grep "/example/"` | tail -1 | sed 's/total//' - -## SKIP since 0 -##wc -l `find . -name "*.scala" -exec grep "DI:LI:AD" {} \; -print | grep "/example/"` -echo "DI:LI:AD 0" - -echo -n "DI:LD:AI " -wc -l `find . -name "*.scala" -exec grep "DI:LD:AI" {} \; -print | grep "/example/"` | tail -1| sed 's/total//' - -echo -n "DI:LD:AD " -wc -l `find . -name "*.scala" -exec grep "DI:LD:AD" {} \; -print | grep "/example/"` | tail -1| sed 's/total//' - -echo -n "DD:LI:AI " -wc -l `find . -name "*.scala" -exec grep "DD:LI:AI" {} \; -print | grep "/example/"` | tail -1| sed 's/total//' - -## SKIP since 0 -##wc -l `find . -name "*.scala" -exec grep "DD:LI:AD" {} \; -print | grep "/example/"` -echo "DD:LI:AD 0" - -echo -n "DD:LD:AI " -wc -l `find . -name "*.scala" -exec grep "DD:LD:AI" {} \; -print | grep "/example/"` | tail -1| sed 's/total//' - -echo -n "DD:LD:AD " -wc -l `find . -name "*.scala" -exec grep "DD:LD:AD" {} \; -print | grep "/example/"` | tail -1| sed 's/total//' diff --git a/language/java/src/main/java/buildTest/TestSynthesis.java b/language/java/src/main/java/buildTest/TestSynthesis.java deleted file mode 100644 index 3da9085f..00000000 --- a/language/java/src/main/java/buildTest/TestSynthesis.java +++ /dev/null @@ -1,319 +0,0 @@ -package buildTest; - -import java.util.*; -import java.io.*; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.stream.Stream; - -/** - * With new dynamic routes, we lose the information in the file. - */ -public class TestSynthesis { - - static final String resources = "language" + File.separator + "java" + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "routes"; - - /** All synthesized files are stored in demo folder. */ - static final String destination = "attic" + File.separator + "demo" + File.separator + "ep"; - - static final String junitJarFile = new File(destination + File.separator + "junit.jar").getAbsoluteFile().toString(); - - /** - * Use git clone to retrieve the source files and move to destination/family/model - * - * @return true on success. false otherwise - */ - static boolean gitRetrieve(String family,String model) { - String url = String.format("http://localhost:9000/%s/%s/%s.git", family, model, model); - File dir = new File (destination); - if (!dir.exists() && !dir.mkdir()) { - System.err.println (" unable to make directory:" + destination); - return false; - } - - // Make family folder (if not yet there) - File child = new File (dir, family); - if (!child.exists() && !child.mkdir()) { - System.err.println (" unable to make directory:" + dir + File.separatorChar + family); - return false; - } - // git clone -n variation_0 http://localhost:9000/freecell/doublefreecell/doublefreecell.git - //String command = "git clone -b variation_0 " + url; - ArrayList gitCommand = new ArrayList<>(); - gitCommand.add("git"); - gitCommand.add("clone"); - gitCommand.add("-b"); - gitCommand.add("variation_0"); - gitCommand.add(url); - - System.out.println (" Clone into " + child); - try { - //Process proc = Runtime.getRuntime().exec(command, new String[0], child); - ProcessBuilder pb = new ProcessBuilder(gitCommand); - pb.directory(child); - - Process proc = pb.start(); - System.out.println (" Errors (if any):"); System.out.flush(); - Stream err = new BufferedReader(new InputStreamReader(proc.getErrorStream())).lines(); - err.forEach(System.err::println); System.err.flush(); - System.out.println (" Output (if any):"); System.out.flush(); - Stream out = new BufferedReader(new InputStreamReader(proc.getInputStream())).lines(); - out.forEach(System.out::println); - System.out.println (" ----"); System.out.flush(); - proc.waitFor(); - return true; - } catch (Exception e) { - System.err.println (" Unable to exec git command" + gitCommand); - return false; - } - } - - /** - * Report on changes - * - * A file.java [added] - * - * TODO: Complete - */ - static Iterator compare(String family, String newer, String older) { - // File dirNew = new File(new File(destination, family), newer); - //File dirOld = new File(new File(destination, family), older); - - // for every file in 'dirNew' check if exists in dirOld, and if changed. - // TBA - return new ArrayList().iterator(); - } - - /** - * Compile the classes as found in the given location - * - * @return true on success; false otherwise - */ - static boolean compile(String family, String model) { - //File here = new File ("."); - - File dir = new File (destination, family); - if (!dir.exists()) { - System.err.println ("USER.DIR:" + System.getProperty("user.dir")); - System.err.println (" unable to locate destination family directory:" + dir); - return false; - } - dir = new File (dir, model); - if (!dir.exists()) { - System.err.println ("USER.DIR:" + System.getProperty("user.dir")); - System.err.println (" unable to locate destination model directory:" + dir); - return false; - } - dir = new File (dir, "src"); - dir = new File (dir, "main"); - dir = new File (dir, "java"); - - // find directory name(s) - File children[] = dir.listFiles(); - ArrayList compileCommand = new ArrayList<>(); - compileCommand.add("javac"); - compileCommand.add("-cp"); - compileCommand.add(junitJarFile + File.pathSeparator + "."); - String fs = File.separator; - - String pkgName = family; - - // The test cases are in the package that contains "TestSuite1.java"; be sure to look for it. - if (children == null || children.length == 0) { - compileCommand.add("." + fs + "*.java"); // not sure what to do - } else { - for (File child : children) { - if (!child.getName().startsWith(".")) { - File testSuite = new File (child, "TestSuite1.java"); - if (testSuite.exists()) { - pkgName = child.getName(); - } - compileCommand.add(child.getName() + fs + "*.java"); - } - } - } - - String[] args = compileCommand.toArray(new String[0]); - - try { - //Process proc = Runtime.getRuntime().exec(args, new String[0], dir); - ProcessBuilder pb = new ProcessBuilder(compileCommand); - pb.directory(dir); - - Process proc = pb.start(); - System.out.println (" Errors (if any):"); System.out.flush(); - Stream err = new BufferedReader(new InputStreamReader(proc.getErrorStream())).lines(); - err.forEach(System.err::println); System.err.flush(); - System.out.println (" Output (if any):"); System.out.flush(); - Stream out = new BufferedReader(new InputStreamReader(proc.getInputStream())).lines(); - out.forEach(System.out::println); - System.out.println (" ----"); System.out.flush(); - proc.waitFor(); - int exitVal = proc.exitValue(); - if (exitVal == 0) { - - // execute JUnit 3 test cases for all .TestSuiteN where N is an integer from 0.. - boolean success = true; - int testNum = 0; - while (true) { - String testSuite = pkgName + ".TestSuite" + testNum; - - File testFile = new File(new File(dir, pkgName), "TestSuite" + testNum + ".java"); - testNum++; - - if (!testFile.exists()) { break; } - - ArrayList testCommand = new ArrayList<>(); - testCommand.add("java"); - testCommand.add("-cp"); - testCommand.add(junitJarFile + File.pathSeparator + "."); - testCommand.add("junit.textui.TestRunner"); - testCommand.add(testSuite); - - pb = new ProcessBuilder(testCommand); - pb.directory(dir); - proc= pb.start(); - - File outputFile = new File(new File(destination, family), model + ".coverage.html"); - - // append all output here... - PrintStream ps = new PrintStream(new FileOutputStream(outputFile, true)); - err = new BufferedReader(new InputStreamReader(proc.getErrorStream())).lines(); - out = new BufferedReader(new InputStreamReader(proc.getInputStream())).lines(); - proc.waitFor(); - int retVal = proc.exitValue(); - - if (retVal != 0) { - System.err.println ("RetVal is not 0:" + retVal); - success = false; - } - - ps.println("

Test Suite:" + pkgName + ".TestSuite" + (testNum-1) + "

"); - ps.println("

RetVal:" + retVal); - ps.println("

Errors (if any):

"); - ps.flush(); - out.forEach(line -> ps.println(line)); - ps.println("

Output

"); - err.forEach(line -> ps.println(line)); - ps.flush(); - ps.close(); - } - return success; - } else { - System.err.println (" Unable to compile:" + exitVal); - return false; - } - } catch (Exception e) { - System.err.println (" Unable to exec:" + Arrays.toString(args)); - return false; - } - } - - /** - * Launch everything! - * - * All code is stored in nextgen-solitaire/demo/solitaire and can be deleted at any time - * since the generated code is not part of the git repository. - */ - public static void main (String args[]) throws Exception { - - File f = new File(resources); - if (!f.exists()) { - System.err.println(" Cannot find routes file:" + resources); - System.exit(-1); - } - - System.out.println("Extracting all EP variations to:" + destination); - - ArrayList variations = new ArrayList<>(); - Scanner sc = new Scanner(f); - while (sc.hasNextLine()) { - String s = sc.nextLine(); - - // only do JAVA solutions in the 'build' package - Pattern regex = Pattern.compile("->\\s+/\\s+org\\.combinators\\.ep\\.language\\.java\\.deployment\\.(\\w+)\\.(\\w+)"); - Matcher match = regex.matcher(s); - - if (match.find()) { - String family = match.group(1); - String evolutionID = match.group(2); - variations.add(family + "/" + evolutionID); - } - } - - Collections.shuffle(variations); - - // Perform each one in random order, so we can run multiple trials - // i.e., algebra -> {(s -> s-family), (e -> e-family) } - Hashtable> successful = new Hashtable<>(); - for (String var : variations) { - System.out.println("Variation:" + var); - - String fields[] = var.split("/"); - String family = fields[0]; - - // bit of a hack right now. fields[1] will be something like E3_Variation or S1_Variation. - // We only want 'e3' or 's3'. - // keep track of all successful variations, as well as highest id for each one. - int underscore = fields[1].indexOf('_'); - if (underscore == -1) { underscore = 2; } - int id; - try { - id = Integer.valueOf(fields[1].substring(1, underscore)); // only grab digits UP TO _ - } catch (NumberFormatException nfe) { - System.err.println (" ** Skipping " + var); - continue; - } - String prefix = fields[1].toLowerCase().substring(0,1); - - String variation = prefix + id; - if (gitRetrieve(family, variation)) { - if (compile(family, variation)) { - - // create Hashtable if not already there... - if (!successful.containsKey(family)) { - successful.put(family, new Hashtable<>()); - } - Hashtable fam = successful.get(family); - - // for the given family, see if prefix exists. Add if not already there... - if (!fam.containsKey(prefix)) { - fam.put(prefix, new Family(prefix)); - } - - // add successful variation to this prefix for given family. - Family pf = fam.get(prefix); - pf.add(id); - - } else { - System.err.println ("RETRIEVED " + family + variation + " but failed to compile."); - } - } - } - - // compare differences with each family and prefix, starting with highest known ID and working backwards - for (String family : successful.keySet()) { - System.out.println("Family: " + family); - - Hashtable ht = successful.get(family); - - for (String prefix : ht.keySet()) { - System.out.print (" prefix-" + prefix + " "); - for (String var : ht.get(prefix)) { - System.out.print(var + " "); - } - } - -// Use these commands to determine what code changed -// git clone -b variation_0 http://localhost:9000/algebra/e5/e5.git -// cd e5 -// git remote add -f b http://localhost:9000/algebra/e4/e4.git -// git remote update -// git diff remotes/b/variation_0 variation_0 --diff-filter=A --name-only -// git diff remotes/b/variation_0 variation_0 --diff-filter=M --name-only -// git diff remotes/b/variation_0 variation_0 --diff-filter=D --name-only - - System.out.println(); - } - } -} diff --git a/language/java/src/main/java/make/Create.java b/language/java/src/main/java/make/Create.java deleted file mode 100644 index c4e5b637..00000000 --- a/language/java/src/main/java/make/Create.java +++ /dev/null @@ -1,280 +0,0 @@ -package make; - -import java.io.*; -import java.util.*; - -/** - * Create the routes file to be used by Play engine and individual Scala classes that represent the specific - * evolutions for different languages and approaches. - */ -public class Create { - - /** - * Where routes file is to be placed for play. Each language has a subdirectory for routes. - */ - static final String routePath = "src" + File.separatorChar + "main" + File.separatorChar + "resources" + File.separatorChar + "routes"; - - /** - * All synthesized scala build files are stored in this package. Prefix with language, and suffix by 'approach/' + build.scala - */ - static final String destinationPath(String lang) { - return "language" + File.separatorChar + lang + File.separatorChar + "src" + - File.separatorChar + "main" + File.separatorChar + "scala" + - File.separatorChar + "org" + File.separatorChar + "combinators" + - File.separatorChar + "ep" + File.separatorChar + "language" + - File.separatorChar + lang + File.separatorChar + "deployment"; - } - - /** Known Java Variations to generate. */ - static final Evolution[] extendedEvolutions = { - new Evolution ("M0"), - new Evolution ("M1", "M0"), - new Evolution ("M2", "M1"), - new Evolution ("M3", "M2"), - new Evolution ("M4", "M3"), - new Evolution ("M5", "M4"), - new Evolution ("M6", "M5"), - new Evolution ("M7", "M6"), - new Evolution ("M8", "M7"), - }; - - /** Known Variations to generate. */ - static final Evolution[] standardEvolutions = { - new Evolution ("M0"), - new Evolution ("M1", "M0"), - new Evolution ("M2", "M1"), - new Evolution ("M3", "M2"), - new Evolution ("M4", "M3"), - new Evolution ("M5", "M4"), - new Evolution ("M6", "M5"), - }; - - /** Known Java Variations to generate. */ - static final Evolution[] gjEvolutions = { - new Evolution ("M0"), - new Evolution ("M1", "M0"), - }; - - static Instance getJavaName = new Instance() { - public String instance(String name) { - if (name.charAt(0) == 'M') { - return "e" + name.charAt(1); - } - - return name.toLowerCase(); - } - }; - - static Instance getScalaName = new Instance() { - public String instance(String name) { - if (name.charAt(0) == 'M') { - return "e" + name.charAt(1); - } - - return name.toLowerCase(); - } - }; - - static Instance getCPPName = new Instance() { - public String instance(String name) { - if (name.charAt(0) == 'M') { - return "cpp_e" + name.charAt(1); - } - - // nothing else. - return name.toLowerCase(); - } - }; - - static Instance getHaskellName = new Instance() { - public String instance(String name) { - if (name.charAt(0) == 'M') { - return "e" + name.charAt(1); - } - - // nothing else. - return name.toLowerCase(); - } - }; - - static Instance getGJName = new Instance() { - public String instance(String name) { - if (name.charAt(0) == 'M') { - return "e" + name.charAt(1); - } - - return name.toLowerCase(); - } - }; - - /** Known Java Variations to generate. */ - static final Evolution[] independentEvolutions = { - new Evolution("I1", "M1"), - new Evolution("I2", "I1"), - new Evolution("P1", "M2") - }; - - // HACK. TODO: Has to be M3 first otherwise ordering in generated code doesn't match. - static final Evolution[] mergedEvolutions = { - new MergedEvolution("C1", "M3", "I2") - }; - - static final Evolution[] shapeEvolutions = { - new Evolution("S0"), - new Evolution("S1", "S0") - }; - - // each language has a number of possible variations. Names of languages are used to - // construct package names, i.e., "ep.j" and "ep.haskell" - static final Language lang_java = new Language("java") - .addEvolutions("math.MathDomain", "Foundation", extendedEvolutions) - .addEvolutions("math.MathDomain", "Foundation", independentEvolutions) - .addEvolutions("shape.ShapeDomain", "ShapeFoundation", shapeEvolutions) - .addMapping(getJavaName) - .addEvolutions("math.MathDomain", "Foundation", mergedEvolutions) - .add("algebra", "WithDomain(%DOMAIN%) with AlgebraGenerator with AlgebraTestGenerator") - .add("extensibleVisitor", "WithDomain(%DOMAIN%) with ExtensibleVisitorGenerator with ExtensibleVisitorTestGenerator") - .add("interpreter", "WithDomain(%DOMAIN%) with InterpreterGenerator with InterpreterTestGenerator") - .add("oo", "WithDomain(%DOMAIN%) with OOGenerator with JUnitTestGenerator") - .add("trivially", "WithDomain(%DOMAIN%) with TriviallyGenerator with TriviallyTestGenerator") - .add("visitor", "WithDomain(%DOMAIN%) with VisitorGenerator with JUnitTestGenerator"); - - static final Language lang_haskell = new Language("haskell") - .addMapping(getHaskellName) - .addEvolutions("math.MathDomain", "Foundation", standardEvolutions) - .add("alacarte", "WithDomain(%DOMAIN%) with ALaCarteGenerator with ALaCarteTestGenerator") - .add("grow", "WithDomain(%DOMAIN%) with GrowGenerator with GrowTestGenerator") - .add("straight", "WithDomain(%DOMAIN%) with StraightGenerator with StraightTestGenerator"); - - static final Language lang_cpp = new Language("cpp") - .addMapping(getCPPName) - .addEvolutions("math.MathDomain", "Foundation", standardEvolutions) - .add("oo", "WithDomain(%DOMAIN%) with StraightGenerator with CPPOOTestGenerator") - .add("visitor", "WithDomain(%DOMAIN%) with CPPVisitorGenerator with CPPVisitorTestGenerator") - .add("visitorTable", "WithDomain(%DOMAIN%) with CPPVisitorTableGenerator with CPPTableTestGenerator"); - - static final Language lang_scala= new Language("scala") - .addMapping(getScalaName) - .addEvolutions("math.MathDomain", "Foundation", standardEvolutions) - .add("oo","WithDomain(%DOMAIN%) with OderskyGenerator with FunSpecOOTestGenerator") - .add("functional", "WithDomain(%DOMAIN%) with FunctionalGenerator with FunSpecFunctionalTestGenerator") - .add("straight", "WithDomain(%DOMAIN%) with OOGenerator with FunSpecTestGenerator"); - - static final Language lang_gj = new Language("gj") - .addMapping(getGJName) - .addEvolutions("math.MathDomain", "Foundation", gjEvolutions) - .add("wadler", "WithDomain(%DOMAIN%) with WadlerGenerator with UnitTestGenerator"); // not really anything good - - /** Could have used reflection, but this is simpler. */ - static final Language[] allLanguages = { lang_java, lang_haskell, lang_cpp, lang_gj, lang_scala }; - - /** - * Returns Scala class to represent the instantiation of this desired evolution. - * - * @param lang desired language for which deployment object is created - * @param ev desired evolution - * @param packageStruct scala package into which file is created. - */ - static String create(Language lang, Evolution ev, String packageStruct) { - String name = ev.name; - String foundation = lang.getFoundation(name); - String scalaClass = "class " + name + "_Variation @Inject()(web: WebJarsUtil, app: ApplicationLifecycle) extends " + foundation + "(web, app) {"; - String evolutions = ""; - - // lower-case names for all evolutions. Must make sure no duplicates - // LAST ONE selected is the name of the evolution to be selected. - Iterator past = ev.evolutions(); - - while (past.hasNext()) { - String ps = past.next(); - String trait = lang.mapping.instance(ps); - if (evolutions.equals("")) { - evolutions = trait; - } else { - evolutions = trait + " with " + evolutions; - } - } - - // replace %DOMAIN% with proper domain. - String domain = lang.getDomain(name); - packageStruct = packageStruct.replace("%DOMAIN%", domain); - String override = "override val gen = new " + packageStruct.replace("[", "(").replace("]", ")") + " with " + evolutions; - - return scalaClass + "\n" + override + "\n}"; - } - - /** - * Each Routes entry is of the following form: - * - * -> / ep.scala.oo.M0_Variation - * - * Also creates the necessary deployment/ files in each language - */ - public static void main(String[] args) throws Exception { - // for each language - for (Language lang : allLanguages) { - File rf = new File ("language" + File.separatorChar + lang.name + File.separatorChar + routePath); - PrintWriter routesFile = new PrintWriter(rf); - - // make sure deployment directory exists - File output = new File(destinationPath(lang.name)); - if (!output.exists()) { - output.mkdir(); - } - - // for each family - for (String variation: lang) { - //String packageName = "build." + lang.name + "." + variation; - String packageName = "org.combinators.ep.language." + lang.name + ".deployment." + variation; - String packageStruct = lang.constructors.get(variation); - - // variation directory needs to be created. - File varDir = new File (output, variation); - if (!varDir.exists()) { - varDir.mkdir(); - } - File build = new File (varDir, "build.scala"); - System.out.println (" " + lang.name + "\t" + variation ); - - try { - PrintWriter pw_output = new PrintWriter(build); - - pw_output.println("package " + packageName); - pw_output.println("/* Generated: " + new Date() + " */"); - pw_output.println("import org.combinators.ep.domain.math._"); - pw_output.println("import org.combinators.ep.domain._"); - pw_output.println("import org.combinators.ep.language." + lang.name + "._"); - pw_output.println("import org.combinators.ep.language." + lang.name + "." + variation + "._"); - pw_output.println("import javax.inject.Inject"); - pw_output.println("import org.webjars.play.WebJarsUtil"); - pw_output.println("import play.api.inject.ApplicationLifecycle"); - - //String traits = ""; - routesFile.println ("# " + variation + "(" + lang.name + ") evolutions: "); - for (Evolution ev : lang.evolutions) { - System.out.print (ev.name + ", "); - String clazzDefinition = create(lang, ev, packageStruct); - - pw_output.println("/* "); - pw_output.println(" * " + variation + " solution in " + lang.name + " for " + ev.name); - pw_output.println(" * "); - pw_output.println(" * @group evolutions "); - pw_output.println(" */"); - - pw_output.println(clazzDefinition); - // output routes information - routesFile.println ("->\t/\t\t " + packageName + "." + ev.name + "_Variation"); - } - System.out.println(); - pw_output.close(); - } catch (IOException ioe) { - ioe.printStackTrace(); - } - } - - routesFile.close(); - System.out.println ("Generated Routes file: " + rf.getAbsoluteFile()); - } - } - -} diff --git a/language/java/src/main/java/make/Evolution.java b/language/java/src/main/java/make/Evolution.java deleted file mode 100644 index d84b5a35..00000000 --- a/language/java/src/main/java/make/Evolution.java +++ /dev/null @@ -1,47 +0,0 @@ -package make; - -import java.util.*; - -/** - * Represents a step in an evolution. - */ -public class Evolution { - - static Hashtable map = new Hashtable<>(); - - final String prior; - final String name; - - public Evolution (String name) { - this.prior = null; - this.name = name; - map.put(name, this); - } - - public Evolution (String name, String prior) { - this.name = name; - this.prior = prior; - map.put(name, this); - } - - boolean isSimple() { return true; } - - public Iterator evolutions() { return selfAndPast(name); } - - // prior evolutions (assumes no cycles!) - public Iterator selfAndPast(String n) { - ArrayList names = new ArrayList<>(); - while (n != null) { - names.add(n); - if (map.containsKey(n)) { - Evolution e = map.get(n); - n = e.prior; - } else { - System.out.println ("ERROR: no prior evolution" + n); - break; - } - } - - return names.iterator(); - } -} diff --git a/language/java/src/main/java/make/Instance.java b/language/java/src/main/java/make/Instance.java deleted file mode 100644 index 9c8e1a10..00000000 --- a/language/java/src/main/java/make/Instance.java +++ /dev/null @@ -1,9 +0,0 @@ -package make; - -public interface Instance { - - /** - * Return the name of the instance associated with evolution - */ - String instance(String ev); -} diff --git a/language/java/src/main/java/make/Language.java b/language/java/src/main/java/make/Language.java deleted file mode 100644 index e4834fc2..00000000 --- a/language/java/src/main/java/make/Language.java +++ /dev/null @@ -1,64 +0,0 @@ -package make; - -import java.util.*; - -/** - * Helper class to keep track of the different language implementations, and contain the - * information needed to generate the necessary Scala code for build/deployment - */ -public class Language implements Iterable { - public final String name; - final ArrayList impls = new ArrayList<>(); - - final ArrayList evolutions = new ArrayList<>(); - final Hashtable domains = new Hashtable<>(); - final Hashtable foundations = new Hashtable<>(); - - final Hashtable constructors = new Hashtable<>(); - - /** Mapping of evolution names to instances. */ - Instance mapping; - - public Language (String lang) { this.name = lang; } - - public Language add(String name, String scalaConstructor) { - if (!impls.contains(name)) { - impls.add(name); - constructors.put(name, scalaConstructor); - } - return this; - } - - public Language addMapping(Instance inst) { - this.mapping = inst; - - return this; - } - - /** Add a number of potential evolutions. */ - public Language addEvolutions(String domainName, String foundationName, Evolution[] evs) { - for (Evolution ev : evs) { - evolutions.add(ev); - domains.put(ev.name, domainName); - foundations.put(ev.name, foundationName); - } - return this; - } - - /** Return all evolutions. */ - public Iterator evolutions() { - return evolutions.iterator(); - } - - /** Return the name of the application domain. */ - public String getDomain(String evName) { return domains.get(evName); } - - /** Get name of class to use for the Foundation trait. */ - public String getFoundation(String evName) { return foundations.get(evName); } - - /** Return all possible families. */ - @Override - public Iterator iterator() { - return impls.iterator(); - } -} diff --git a/language/java/src/main/java/make/MergedEvolution.java b/language/java/src/main/java/make/MergedEvolution.java deleted file mode 100644 index 5d8ffa2c..00000000 --- a/language/java/src/main/java/make/MergedEvolution.java +++ /dev/null @@ -1,45 +0,0 @@ -package make; - -import java.util.ArrayList; -import java.util.Iterator; - -/** - * Handles the merged evolution cases. - */ -public class MergedEvolution extends Evolution { - final String[] priors; - - public MergedEvolution(String name, String... priors) { - super(name); - - int num = priors.length; - this.priors = new String[num]; - for (int i = 0; i < num; i++) { - this.priors[i] = priors[i]; - } - } - - boolean isSimple() { return false; } - - // prior evolutions (assumes no cycles!) - public Iterator evolutions() { - ArrayList all = new ArrayList<>(); - - // don't forget to add self AS FIRST one - all.add(name); - - // place in order. If we revisit one already existing, then delete OLD one - for (String p : priors) { - Iterator it = selfAndPast(p); - while (it.hasNext()) { - String ev = it.next(); - if (all.contains(ev)) { - all.remove(ev); - } - all.add(ev); - } - } - - return all.iterator(); - } -} diff --git a/language/java/src/main/java/make/README.txt b/language/java/src/main/java/make/README.txt deleted file mode 100644 index 4ac1e6e2..00000000 --- a/language/java/src/main/java/make/README.txt +++ /dev/null @@ -1,6 +0,0 @@ -Execute 'Create' to generate all of the */routes files and deployment/build.scala classes - -Prior to this capability, these files were each constructed manually. Whenever a change is -made to the designated Extension Graph, then modify Create.java (hopefully, internal documentation -is sufficient to understand what to do) and then execute it. - diff --git a/language/java/src/main/resources/org/combinators/ep/language/java/gitignore b/language/java/src/main/resources/org/combinators/ep/language/java/gitignore deleted file mode 100644 index dbc10d90..00000000 --- a/language/java/src/main/resources/org/combinators/ep/language/java/gitignore +++ /dev/null @@ -1,44 +0,0 @@ - -# Created by https://www.gitignore.io/api/sbt,java -# Edit at https://www.gitignore.io/?templates=sbt,java - -### Java ### -# Compiled class file -*.class - -# Log file -*.log - -# BlueJ files -*.ctxt - -# Mobile Tools for Java (J2ME) -.mtj.tmp/ - -# Package Files # -*.jar -*.war -*.nar -*.ear -*.zip -*.tar.gz -*.rar - -# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml -hs_err_pid* - -### SBT ### -# Simple Build Tool -# http://www.scala-sbt.org/release/docs/Getting-Started/Directories.html#configuring-version-control - -dist/* -target/ -lib_managed/ -src_managed/ -project/boot/ -project/plugins/project/ -.history -.cache -.lib/ - -# End of https://www.gitignore.io/api/sbt,java diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/CodeGenerator.scala b/language/java/src/main/scala/org/combinators/ep/language/java/CodeGenerator.scala index c6d7fbd2..56754f77 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/CodeGenerator.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/CodeGenerator.scala @@ -4,18 +4,17 @@ import cats.{Apply => _} import com.github.javaparser.ast.PackageDeclaration import com.github.javaparser.ast.`type`.PrimitiveType import com.github.javaparser.ast.expr.{DoubleLiteralExpr, IntegerLiteralExpr, TypeExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command +import org.combinators.cogen.TypeRep +import org.combinators.cogen.Command import org.combinators.ep.language.java.paradigm._ import org.combinators.ep.language.java.paradigm.ffi._ - /** * Java-specific. * * These paradigm-specific traits are conceptually different from each other */ -sealed class CodeGenerator(config: Config) { cc => +class CodeGenerator(config: Config) { cc => val paradigm: AnyParadigm = AnyParadigm(config) val ooParadigm: ObjectOriented[paradigm.type] = ObjectOriented(paradigm) val imperativeInMethod: Imperative[MethodBodyCtxt, paradigm.type] = Imperative.inMethodContext(paradigm) @@ -118,35 +117,19 @@ sealed class CodeGenerator(config: Config) { cc => val listsInMethod = - Lists[MethodBodyCtxt, paradigm.type, generics.type]( + Lists[MethodBodyCtxt, paradigm.type, Generics]( paradigm, - ooParadigm.methodBodyCapabilities.canGetMemberInMethod, - paradigm.methodBodyCapabilities.canApplyInMethodBody, parametricPolymorphism.methodBodyCapabilities.canApplyTypeInMethod, paradigm.methodBodyCapabilities.canAddImportInMethodBody )(generics) val listsInConstructor = - Lists[CtorCtxt, paradigm.type, generics.type]( + Lists[CtorCtxt, paradigm.type, Generics]( paradigm, - ooParadigm.constructorCapabilities.canGetMemberInConstructor, - ooParadigm.constructorCapabilities.canApplyInConstructor, generics.constructorCapabilities.canApplyTypeInConstructor, ooParadigm.constructorCapabilities.canAddImportInConstructor )(generics) - val treesInMethod = - Trees[MethodBodyCtxt, paradigm.type, ObjectOriented]( - paradigm, - paradigm.methodBodyCapabilities.canAddImportInMethodBody - )(ooParadigm) - - val treesInConstructor = - Trees[CtorCtxt, paradigm.type, ObjectOriented]( - paradigm, - ooParadigm.constructorCapabilities.canAddImportInConstructor - )(ooParadigm) - val assertionsInMethod = new Assertions[paradigm.type](paradigm)(ooParadigm) val exceptionsInMethod = new Exceptions[paradigm.type](paradigm) } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/ContextSpecificResolver.scala b/language/java/src/main/scala/org/combinators/ep/language/java/ContextSpecificResolver.scala index 96b16c5c..7b602e34 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/ContextSpecificResolver.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/ContextSpecificResolver.scala @@ -1,12 +1,12 @@ package org.combinators.ep.language.java /*DI:LD:AI*/ -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.Command.Generator +import org.combinators.cogen.Command.Generator import org.combinators.ep.language.java.Syntax.MangledName import Syntax.default._ import com.github.javaparser.ast.ImportDeclaration -import org.combinators.ep.generator.Command +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.Command case class ContextSpecificResolver( _methodTypeResolution: ContextSpecificResolver => TypeRep => Generator[MethodBodyCtxt, Type], diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/FreshNameCleanup.scala b/language/java/src/main/scala/org/combinators/ep/language/java/FreshNameCleanup.scala index 76238f86..a478ae04 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/FreshNameCleanup.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/FreshNameCleanup.scala @@ -1,31 +1,34 @@ -package org.combinators.ep.language.java /*DI:LD:AI*/ +package org.combinators.ep.language.java + +/*DI:LD:AI*/ import com.github.javaparser.ast.body.{ClassOrInterfaceDeclaration, ConstructorDeclaration, MethodDeclaration} import com.github.javaparser.ast.{CompilationUnit, ImportDeclaration, Node} import com.github.javaparser.ast.expr.{CastExpr, LambdaExpr, Name, SimpleName} import com.github.javaparser.ast.stmt.{BlockStmt, CatchClause, ForEachStmt, ForStmt, SwitchEntry, SwitchStmt} import com.github.javaparser.ast.visitor.Visitable -import org.combinators.ep.generator.FreshNameProvider +import org.combinators.cogen.FreshNameProvider import org.combinators.ep.language.java.Syntax.MangledName class FreshNameCleanup(nameInfo: Map[String, MangledName]) { sealed private trait Phase + private case object COLLECT_NAMES extends Phase + private case object REPLACE_GENERATED extends Phase private class CleanupVisitor extends com.github.javaparser.ast.visitor.ModifierVisitor[Phase] { var freshNames: FreshNameProvider[MangledName] = FreshNameProvider[MangledName](pushName) - val replaceName: scala.collection.mutable.Map[String, MangledName] = - new scala.collection.mutable.HashMap[String, MangledName]() { - override def apply(name: String): MangledName = { - getOrElseUpdate(name, { - val baseName = nameInfo(name) - val (replacement, nextNames) = freshNames.freshNameBasedOn(baseName) - freshNames = nextNames - replacement - }) - } - } + private val _replaceName: scala.collection.mutable.Map[String, MangledName] = new scala.collection.mutable.HashMap[String, MangledName]() + + private final def replaceName(name: String): MangledName = { + _replaceName.getOrElseUpdate(name, { + val baseName = nameInfo(name) + val (replacement, nextNames) = freshNames.freshNameBasedOn(baseName) + freshNames = nextNames + replacement + }) + } private final def pushName(name: MangledName, useCounter: Int): MangledName = { if (useCounter == 0) { @@ -126,5 +129,5 @@ class FreshNameCleanup(nameInfo: Map[String, MangledName]) { object FreshNameCleanup { def cleaned(nameInfo: Map[String, MangledName], units: CompilationUnit*): Seq[CompilationUnit] = - new FreshNameCleanup(nameInfo).cleanup(units: _*) + new FreshNameCleanup(nameInfo).cleanup(units *) } \ No newline at end of file diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/ImportCleanup.scala b/language/java/src/main/scala/org/combinators/ep/language/java/ImportCleanup.scala index 8dc4fbcc..71e1f93e 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/ImportCleanup.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/ImportCleanup.scala @@ -6,72 +6,72 @@ import com.github.javaparser.ast.expr.{Name, SimpleName} import com.github.javaparser.ast.visitor.Visitable class ImportCleanup { - case class UsageAnalyzer(usageData: Map[SimpleName, Map[Option[Name], Int]] = Map.empty.withDefaultValue(Map.empty.withDefaultValue(0))) { - def use(name: Name): UsageAnalyzer = { - val simplePart = new SimpleName(name.getIdentifier) - val qualifier = name.getQualifier.map[Option[Name]](Some(_)).orElse(None) - val entry = usageData(simplePart) - copy(usageData = usageData.updated(simplePart, entry.updated(qualifier, entry(qualifier) + 1))) - } - - def toQualifiedName(classOrInterfaceType: ClassOrInterfaceType): Name = { - val simpleName = classOrInterfaceType.getName.getIdentifier - classOrInterfaceType.getScope - .map[Option[ClassOrInterfaceType]](Some(_)).orElse(None) - .map(toQualifiedName) - .map(new Name(_, simpleName)) - .getOrElse(new Name(simpleName)) - } - - def toClassOrInterfaceType(qualifiedName: Name): ClassOrInterfaceType = { - paradigm.ObjectOriented.nameToType(qualifiedName) - } - - def use(classOrInterfaceType: ClassOrInterfaceType): UsageAnalyzer = { - use(toQualifiedName(classOrInterfaceType)) - } - - def mostRelevantFor(name: SimpleName): Name = { - val dataForName = usageData(name) - val unqualified = Option.empty[Name] - if (dataForName.isEmpty || dataForName(unqualified) > 0) { - new Name(name.getIdentifier) - } else { - dataForName.maxBy(_._2)._1 - .map(qualifier => new Name(qualifier, name.getIdentifier)) - .getOrElse(new Name(name.getIdentifier)) - } - } - - def keepImport(importDecl: ImportDeclaration): Boolean = { - val qualifiedImportedName = importDecl.getName - val simpleImportedName = new SimpleName(qualifiedImportedName.getIdentifier) - (importDecl.isStatic - || importDecl.isAsterisk - || (qualifiedImportedName == mostRelevantFor(simpleImportedName) - && usageData(simpleImportedName).nonEmpty)) - } - - def simplify(name: Name): Name = { - val simplePart = new SimpleName(name.getIdentifier) - if (mostRelevantFor(simplePart) == name && usageData(simplePart).nonEmpty) { - new Name(name.getIdentifier) - } else { - name - } - } - - - def simplify(classOrInterfaceType: ClassOrInterfaceType): ClassOrInterfaceType = { - val qualifiedName = toQualifiedName(classOrInterfaceType) - val result = classOrInterfaceType.clone() - if (simplify(qualifiedName) != qualifiedName) { - result.removeScope() - result.setName(qualifiedName.getIdentifier) - } - result - } - } + case class UsageAnalyzer(usageData: Map[SimpleName, Map[Option[Name], Int]] = Map.empty.withDefaultValue(Map.empty.withDefaultValue(0))) { + def use(name: Name): UsageAnalyzer = { + val simplePart = new SimpleName(name.getIdentifier) + val qualifier = name.getQualifier.map[Option[Name]](Some(_)).orElse(None) + val entry = usageData(simplePart) + copy(usageData = usageData.updated(simplePart, entry.updated(qualifier, entry(qualifier) + 1))) + } + + def toQualifiedName(classOrInterfaceType: ClassOrInterfaceType): Name = { + val simpleName = classOrInterfaceType.getName.getIdentifier + classOrInterfaceType.getScope + .map[Option[ClassOrInterfaceType]](Some(_)).orElse(None) + .map(toQualifiedName) + .map(new Name(_, simpleName)) + .getOrElse(new Name(simpleName)) + } + + def toClassOrInterfaceType(qualifiedName: Name): ClassOrInterfaceType = { + paradigm.ObjectOriented.nameToType(qualifiedName) + } + + def use(classOrInterfaceType: ClassOrInterfaceType): UsageAnalyzer = { + use(toQualifiedName(classOrInterfaceType)) + } + + def mostRelevantFor(name: SimpleName): Name = { + val dataForName = usageData(name) + val unqualified = Option.empty[Name] + if (dataForName.isEmpty || dataForName(unqualified) > 0) { + new Name(name.getIdentifier) + } else { + dataForName.maxBy(_._2)._1 + .map(qualifier => new Name(qualifier, name.getIdentifier)) + .getOrElse(new Name(name.getIdentifier)) + } + } + + def keepImport(importDecl: ImportDeclaration): Boolean = { + val qualifiedImportedName = importDecl.getName + val simpleImportedName = new SimpleName(qualifiedImportedName.getIdentifier) + (importDecl.isStatic + || importDecl.isAsterisk + || (qualifiedImportedName == mostRelevantFor(simpleImportedName) + && usageData(simpleImportedName).nonEmpty)) + } + + def simplify(name: Name): Name = { + val simplePart = new SimpleName(name.getIdentifier) + if (mostRelevantFor(simplePart) == name && usageData(simplePart).nonEmpty) { + new Name(name.getIdentifier) + } else { + name + } + } + + + def simplify(classOrInterfaceType: ClassOrInterfaceType): ClassOrInterfaceType = { + val qualifiedName = toQualifiedName(classOrInterfaceType) + val result = classOrInterfaceType.clone() + if (simplify(qualifiedName) != qualifiedName) { + result.removeScope() + result.setName(qualifiedName.getIdentifier) + } + result + } + } sealed private trait Phase private case object ANALYZE extends Phase @@ -148,5 +148,5 @@ class ImportCleanup { object ImportCleanup { def cleaned(units: CompilationUnit*): Seq[CompilationUnit] = - new ImportCleanup().cleanup(units: _*) + new ImportCleanup().cleanup(units*) } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/JavaNameProvider.scala b/language/java/src/main/scala/org/combinators/ep/language/java/JavaNameProvider.scala index 7a6505c3..80d04763 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/JavaNameProvider.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/JavaNameProvider.scala @@ -1,6 +1,6 @@ package org.combinators.ep.language.java /*DI:LD:AI*/ -import org.combinators.ep.generator.NameProvider +import org.combinators.cogen.NameProvider import Syntax.MangledName import com.github.javaparser.{JavaParser, StaticJavaParser} @@ -8,7 +8,7 @@ import scala.util.Try /** Provides name mangling for Java */ object JavaNameProvider extends NameProvider[MangledName] { - val parser = new JavaParser(StaticJavaParser.getConfiguration) + val parser = new JavaParser(StaticJavaParser.getParserConfiguration) /** Need to have single-param version so this can be used in map. */ def mangle(name: String): MangledName = { diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/OperatorExprs.scala b/language/java/src/main/scala/org/combinators/ep/language/java/OperatorExprs.scala index 38e005c2..c04c126f 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/OperatorExprs.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/OperatorExprs.scala @@ -1,8 +1,8 @@ package org.combinators.ep.language.java /*DI:LD:AI*/ import com.github.javaparser.ast.expr.{BinaryExpr, EnclosedExpr, Expression, UnaryExpr} -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.Apply +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.Understands /** * Operator Expressions are enclosed with parens (EnclosedExpr) to ensure correctness, even though this might @@ -28,7 +28,7 @@ object OperatorExprs { context: Ctxt, command: Apply[Op, Expression, Expression] ): (Ctxt, Expression) = { - import scala.language.reflectiveCalls + import scala.reflect.Selectable.reflectiveSelectable // needed for next statement if (command.functional.shortcut) { (context, new EnclosedExpr (new BinaryExpr(command.arguments(0), command.arguments(1), shortCutOp))) } else { diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/ResourcePersistable.scala b/language/java/src/main/scala/org/combinators/ep/language/java/ResourcePersistable.scala index 76714f51..2afab2a7 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/ResourcePersistable.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/ResourcePersistable.scala @@ -1,10 +1,8 @@ package org.combinators.ep.language.java /*DI:LD:AI*/ -import java.nio.file.{FileSystems, Files, Path, Paths} +import java.nio.file.Path import org.combinators.templating.persistable.{BundledResource, Persistable} -import java.io.ByteArrayOutputStream - trait ResourcePersistableInstances { def bundledResourceInstance: ResourcePersistable.Aux = new Persistable { override type T = BundledResource diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/ShapeMain.scala b/language/java/src/main/scala/org/combinators/ep/language/java/ShapeMain.scala deleted file mode 100644 index fe27843a..00000000 --- a/language/java/src/main/scala/org/combinators/ep/language/java/ShapeMain.scala +++ /dev/null @@ -1,216 +0,0 @@ -package org.combinators.ep.language.java /*DD:LD:AD*/ - -/** - * To generate a single approach for a single stage in an Extension Graph, see [[DirectToDiskMainForShape]] - * which you can either modify directly in the editor and execute, or from the command line, type: - * - * ```sbt "language-java/runMain org.combinators.ep.language.java.DirectToDiskMainForShape APPROACH EIP"``` - * - * APPROACH is one of: graphviz, oo, visitor, visitorSideEffect, extensibleVisitor - * interpreter, coco, trivially, dispatch, algebra - * - * EIP is one of the designated stages: S0, S1, S2 - * - * To generate all evolution stages for all systems, see [[GenerateAllForShape]] - * - * ```sbt "language-java/runMain org.combinators.ep.language.java.GenerateAllForShape"``` - * - * This will generate directories in target/shape - */ - -import cats.effect.{ExitCode, IO, IOApp} -import org.apache.commons.io.FileUtils -import org.combinators.ep.approach.oo.{CoCoClean, ExtensibleVisitor, Interpreter, ObjectAlgebras, RuntimeDispatch, Traditional, TriviallyClean, Visitor, Visualize} -import org.combinators.ep.domain.GenericModel -import org.combinators.ep.domain.abstractions.TestCase -import org.combinators.ep.domain.shape._ -import org.combinators.ep.domain.shape.S0 -import org.combinators.ep.generator.{FileWithPath, FileWithPathPersistable, TestImplementationProvider} -import org.combinators.jgitserv.{BranchTransaction, GitService} -import org.combinators.ep.generator.FileWithPathPersistable._ - -import java.nio.file.{Path, Paths} - -/** - * Eventually encode a set of subclasses/traits to be able to easily specify (a) the variation; and (b) the evolution. - */ -class ShapeMain(choice:String, select:String) { - val generator = CodeGenerator(CodeGenerator.defaultConfig.copy(boxLevel = PartiallyBoxed)) - val visualizeApproach = Visualize[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm) - - val ooApproach = Traditional[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm) - - val visitorApproach = Visitor[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) - val visitorSideEffectApproach = Visitor.withSideEffects[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.imperativeInMethod, generator.ooParadigm) - val extensibleVisitorApproach = ExtensibleVisitor[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) - val interpreterApproach = Interpreter[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) - val cocoCleanApproach = CoCoClean[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) - val algebraApproach = ObjectAlgebras[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm, generator.parametricPolymorphism)(generator.generics) - val dispatchApproach = RuntimeDispatch[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.imperativeInMethod, generator.stringsInMethod, generator.exceptionsInMethod, generator.ooParadigm) - val triviallyCleanApproach = TriviallyClean[Syntax.default.type, generator.paradigm.type](generator.paradigm)(JavaNameProvider, generator.ooParadigm) - - // select one here - val approach = choice match { - case "graphviz" => visualizeApproach - case "oo" => ooApproach - case "visitor" => visitorApproach - case "visitorSideEffect" => visitorSideEffectApproach - case "extensibleVisitor" => extensibleVisitorApproach - case "interpreter" => interpreterApproach - case "coco" => cocoCleanApproach - case "trivially" => triviallyCleanApproach - case "dispatch" => dispatchApproach - case "algebra" => algebraApproach - - case _ => ??? - } - - val evolutions = select match { - case "S0" => Seq(S0) - case "S1" => Seq(S0, S1) - case "S2" => Seq(S0, S1, S2) - - case _ => ??? - } - - val s0_eip = - eips.S0(approach.paradigm)( - ffiArithmetic = generator.doublesInMethod, - generator.realDoublesInMethod, - generator.booleansInMethod, - generator.stringsInMethod - ) - val s1_eip = eips.S1(approach.paradigm)(s0_eip)( - generator.doublesInMethod, - generator.booleansInMethod - ) - val s2_eip = eips.S2(approach.paradigm)(s1_eip)( - generator.doublesInMethod, - generator.imperativeInMethod - ) - - val eip = select match { - case "S0" => s0_eip - case "S1" => s1_eip - case "S2" => s2_eip - - case _ => ??? - } - - val tests = evolutions.scanLeft(Map.empty[GenericModel, Seq[TestCase]]) { case (m, evolution) => - m + (evolution.getModel -> evolution.tests) - }.tail - - // for CoCo, we only need the latest since all earlier ones are identical - val all = evolutions.zip(tests) - - def transaction[T](initialTransaction: T, addToTransaction: (T, String, () => Seq[FileWithPath]) => T): T = { - all.foldLeft(initialTransaction) { case (transaction, (evolution, tests)) => - val impl = - () => generator.paradigm.runGenerator { - for { - _ <- approach.implement(evolution.getModel, eip) - _ <- approach.implement( - tests, - TestImplementationProvider.defaultAssertionBasedTests(approach.paradigm)(generator.assertionsInMethod, generator.equalityInMethod, generator.booleansInMethod, generator.stringsInMethod) - ) - } yield () - } - addToTransaction(transaction, evolution.getModel.name, impl) - } - } - - val persistable = FileWithPathPersistable[FileWithPath] - - def gitTransaction: Option[BranchTransaction] = - transaction[Option[BranchTransaction]](Option.empty, (transaction, evolutionName, files) => { - val nextTransaction = - transaction.map(_.fork(evolutionName).deleteAllFiles) - .getOrElse(BranchTransaction.empty(evolutionName)) - Some(nextTransaction.persist(files())(persistable).commit("Adding next evolution")) - }) - - def directToDiskTransaction(targetDirectory: Path): IO[Unit] = { - transaction[IO[Unit]](IO.unit, (transaction, evolutionName, files) => IO { - print("Computing Files...") - val computed = files() - println("[OK]") - if (targetDirectory.toFile.exists()) { - print(s"Cleaning Target Directory ($targetDirectory)...") - FileUtils.deleteDirectory(targetDirectory.toFile) - println("[OK]") - } - print("Persisting Files...") - files().foreach(file => persistable.persistOverwriting(targetDirectory, file)) - println("[OK]") - }) - } - - def runGit(args: List[String]): IO[ExitCode] = { - val name = evolutions.head.getModel.base.name - for { - _ <- IO { System.out.println(s"Use: git clone http://127.0.0.1:8081/$name ${evolutions.last.getModel.name}") } - exitCode <- new GitService(gitTransaction.toSeq, name).run(args) - } yield exitCode - } - - def runDirectToDisc(targetDirectory: Path): IO[ExitCode] = { - for { - _ <- directToDiskTransaction(targetDirectory) - } yield ExitCode.Success - } -} - -object GenerateAllForShape extends IOApp { - - def run(args: List[String]): IO[ExitCode] = { - - val approaches = Seq("oo", "visitor", "extensibleVisitor", "interpreter", "coco", "trivially", "algebra") - val evolutions = Seq("S0", "S1", "S2") - - approaches.foreach(approach => { - println("Generating " + approach + "...") - evolutions.foreach(selection => { - println(" " + selection) - - val targetDirectory = Paths.get("target", "shape", approach, selection) - val program :IO[Unit] = { - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new ShapeMain(approach, selection) } - - _ <- IO { println("[OK]") } - _ <- main.runDirectToDisc(targetDirectory) - } yield () - } - - // execute above as a stand-alone program - program.unsafeRunSync() - - // TBD: Would be nice to launch 'sbt' in each of these generated directories - }) - }) - - for { - _ <- IO { print("DONE") } - } yield ExitCode.Success - - } -} - -object DirectToDiskMainForShape extends IOApp { - val targetDirectory = Paths.get("target", "shape") - - def run(args: List[String]): IO[ExitCode] = { - val approach = if (args.isEmpty) "graphviz" else args.head - if (approach == "exit") { sys.exit(0) } - val selection = if (args.isEmpty || args.tail.isEmpty) "S2" else args.tail.head - - for { - _ <- IO { print("Initializing Generator...") } - main <- IO { new ShapeMain(approach, selection) } - _ <- IO { println("[OK]") } - result <- main.runDirectToDisc(targetDirectory) - } yield result - } -} \ No newline at end of file diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/Syntax.scala b/language/java/src/main/scala/org/combinators/ep/language/java/Syntax.scala index b355a20b..187a688c 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/Syntax.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/Syntax.scala @@ -1,8 +1,6 @@ package org.combinators.ep.language.java /*DI:LD:AI*/ -import org.combinators.ep.generator.AbstractSyntax -import cats.data.State -import cats._ +import org.combinators.cogen.AbstractSyntax trait Syntax extends AbstractSyntax { type CompilationUnit = com.github.javaparser.ast.CompilationUnit diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/contexts.scala b/language/java/src/main/scala/org/combinators/ep/language/java/contexts.scala index 74e67507..a4862be4 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/contexts.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/contexts.scala @@ -2,13 +2,15 @@ package org.combinators.ep.language.java /*DI:LD:AI*/ import com.github.javaparser.ast.`type`.TypeParameter import com.github.javaparser.ast.body.{ClassOrInterfaceDeclaration, ConstructorDeclaration, MethodDeclaration} -import org.combinators.ep.language.java.Syntax.default._ +import org.combinators.cogen.FileWithPath +import org.combinators.ep.language.java.Syntax.default.* case class ProjectCtxt( resolver: ContextSpecificResolver, units: Seq[com.github.javaparser.ast.CompilationUnit], testUnits: Seq[com.github.javaparser.ast.CompilationUnit], - extraDependencies: Seq[String] + extraDependencies: Seq[String], + customFiles: Seq[FileWithPath], ) case class CompilationUnitCtxt( resolver: ContextSpecificResolver, diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/AnyParadigm.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/AnyParadigm.scala index 2599ad03..15c01c28 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/AnyParadigm.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/AnyParadigm.scala @@ -2,27 +2,27 @@ package org.combinators.ep.language.java.paradigm /*DI:LD:AI*/ import java.nio.file.Paths import java.util.UUID -import com.github.javaparser.ast.{ImportDeclaration, Modifier, NodeList} +import com.github.javaparser.ast.{ImportDeclaration, Modifier, Node, NodeList} import com.github.javaparser.ast.`type`.VoidType import com.github.javaparser.ast.body.{ClassOrInterfaceDeclaration, MethodDeclaration} -import com.github.javaparser.ast.expr.{MethodCallExpr, NameExpr, NullLiteralExpr} +import com.github.javaparser.ast.expr.{MethodCallExpr, NameExpr, NullLiteralExpr, Name as JName} import com.github.javaparser.ast.nodeTypes.{NodeWithScope, NodeWithSimpleName} import com.github.javaparser.ast.stmt.{BlockStmt, ExpressionStmt} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, FileWithPath, Understands} -import org.combinators.ep.generator.paradigm.{AnyParadigm => AP, _} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AddBlockDefinitions, AddCompilationUnit, AddCustomFile, AddImplementedTestCase, AddImport, AddTestCase, AddTestSuite, AddTypeLookup, Apply, Debug, FreshName, GetArguments, OutputToConsole, Reify, ResolveImport, SetParameters, SetReturnType, ToTargetLanguageType, AnyParadigm as AP, ObjectOriented as _} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, FileWithPath, Understands} import org.combinators.ep.language.java.Syntax.MangledName import org.combinators.ep.language.java.{CodeGenerator, CompilationUnitCtxt, Config, ContextSpecificResolver, FreshNameCleanup, ImportCleanup, JavaNameProvider, MethodBodyCtxt, ProjectCtxt, Syntax, TestCtxt} import org.combinators.templating.persistable.{BundledResource, JavaPersistable} -import org.combinators.ep.language.java.ResourcePersistable import scala.util.Try -import scala.jdk.CollectionConverters._ +import scala.jdk.CollectionConverters.* + trait AnyParadigm extends AP { - val config: Config + lazy val config: Config val syntax: Syntax.default.type = Syntax.default import syntax._ @@ -40,8 +40,8 @@ trait AnyParadigm extends AP { context: ProjectCtxt, command: Debug ): (ProjectCtxt, Unit) = { - - context.units.foreach (u => System.err.println (command.tag + ": " + u)) + val units = context.units.toSeq.mkString(", ") + System.err.println (command.tag + ": " + units) (context,()) } } @@ -96,6 +96,12 @@ trait AnyParadigm extends AP { (context.copy(resolver = context.resolver.copy(_methodTypeResolution = newLookup)), ()) } } + implicit val canAddCustomFile: Understands[ProjectCtxt, AddCustomFile] = + new Understands[ProjectCtxt, AddCustomFile] { + def perform(context: ProjectCtxt, command: AddCustomFile): (ProjectCtxt, Unit) = { + (context.copy(customFiles = context.customFiles :+ command.file), ()) + } + } } val compilationUnitCapabilities: CompilationUnitCapabilities = @@ -293,7 +299,7 @@ trait AnyParadigm extends AP { val stripped = AnyParadigm.stripGenerics(command.forElem) Try { (context, context.resolver.importResolution(stripped)) } getOrElse { if (stripped.isClassOrInterfaceType) { - val importName = ObjectOriented.typeToName(stripped.asClassOrInterfaceType()) + val importName: JName = ObjectOriented.typeToName(stripped.asClassOrInterfaceType()) val newImport = new ImportDeclaration( importName, @@ -317,6 +323,7 @@ trait AnyParadigm extends AP { context: MethodBodyCtxt, command: Apply[Expression, Expression, Expression] ): (MethodBodyCtxt, Expression) = { + import scala.reflect.Selectable.reflectiveSelectable val resultExp: Expression = if (command.functional.isMethodCallExpr) { val res = command.functional.asMethodCallExpr().clone() @@ -325,10 +332,10 @@ trait AnyParadigm extends AP { } else { val scope = command.functional match { - case n: NodeWithScope[Expression] => n.getScope + case n: NodeWithScope[_] => n.getScope case _ => null } - new MethodCallExpr(scope, command.functional.asInstanceOf[NodeWithSimpleName[_]].getNameAsString, new NodeList[Expression](command.arguments: _*)) + new MethodCallExpr(scope, command.functional.asInstanceOf[NodeWithSimpleName[Node]].getNameAsString, new NodeList[Expression](command.arguments*)) } (context, resultExp) } @@ -340,7 +347,7 @@ trait AnyParadigm extends AP { context: MethodBodyCtxt, command: GetArguments[Type, Name, Expression] ): (MethodBodyCtxt, Seq[(Name, Type, Expression)]) = { - val params = context.method.getParameters.asScala.map { param => + val params = context.method.getParameters.asScala.toSeq.map { param => (MangledName.fromAST(param.getName), param.getType, new NameExpr(param.getName)) } (context, params) @@ -381,7 +388,7 @@ trait AnyParadigm extends AP { val stripped = AnyParadigm.stripGenerics(command.forElem) Try { (context, context.resolver.importResolution(stripped)) } getOrElse { if (stripped.isClassOrInterfaceType) { - val importName = ObjectOriented.typeToName(stripped.asClassOrInterfaceType()) + val importName: JName = ObjectOriented.typeToName(stripped.asClassOrInterfaceType()) val newImport = new ImportDeclaration( importName, @@ -496,7 +503,8 @@ trait AnyParadigm extends AP { resolver = defaultResolver, units = Seq.empty, testUnits = Seq.empty, - extraDependencies = Seq.empty + extraDependencies = Seq.empty, + customFiles = Seq.empty ) ) val nameEntry = config.projectName.map(n => s"""name := "$n"""").getOrElse("") @@ -521,11 +529,11 @@ trait AnyParadigm extends AP { """.stripMargin val cleanedUnits = ImportCleanup.cleaned( - FreshNameCleanup.cleaned(finalContext.resolver.generatedVariables, finalContext.units: _*) : _* + FreshNameCleanup.cleaned(finalContext.resolver.generatedVariables, finalContext.units*)* ) val cleanedTestUnits = ImportCleanup.cleaned( - FreshNameCleanup.cleaned(finalContext.resolver.generatedVariables, finalContext.testUnits: _*): _* + FreshNameCleanup.cleaned(finalContext.resolver.generatedVariables, finalContext.testUnits*)* ) val javaFiles = cleanedUnits.map { unit => FileWithPath( @@ -550,7 +558,7 @@ trait AnyParadigm extends AP { //ResourcePersistable.bundledResourceInstance.path(gitIgnore)) +: FileWithPath(pluginFile, Paths.get("project", "plugin.sbt")) +: FileWithPath(buildFile, Paths.get("build.sbt")) +: - (javaFiles ++ javaTestFiles) + (javaFiles ++ javaTestFiles ++ finalContext.customFiles) } } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Generics.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Generics.scala index 172c4e8c..cbf78f29 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Generics.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Generics.scala @@ -1,8 +1,8 @@ package org.combinators.ep.language.java.paradigm /*DI:LD:AI*/ import com.github.javaparser.ast.`type`.{ClassOrInterfaceType, TypeParameter} -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{Generics => Gen, AnyParadigm => _, ObjectOriented => _, _} +import org.combinators.cogen.paradigm.{AddLowerBound, AddTypeParameter, AddUpperBound, Apply, GetCurrentTypeParameter, GetTypeArguments, Generics as Gen, AnyParadigm as _, ObjectOriented as _, ParametricPolymorphism as _} +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.TypeParamCtxt import scala.jdk.CollectionConverters._ @@ -15,8 +15,9 @@ trait Generics[AP <: AnyParadigm] extends Gen { import base.syntax._ import ooParadigm._ import ppolyParadigm._ + val classCapabilities: ClassCapabilities = - new ClassCapabilities { + new ClassCapabilities { implicit val canAddTypeParameterInClass: Understands[ClassContext, AddTypeParameter[Name, TypeParameterContext]] = new Understands[ClassContext, AddTypeParameter[Name, TypeParameterContext]] { def perform(context: ClassContext, command: AddTypeParameter[Name, TypeParameterContext]): (ClassContext, Unit) = { @@ -33,7 +34,7 @@ trait Generics[AP <: AnyParadigm] extends Gen { implicit val canGetTypeArgumentsInClass: Understands[ClassContext, GetTypeArguments[Type]] = new Understands[ClassContext, GetTypeArguments[Type]] { def perform(context: ClassContext, command: GetTypeArguments[Type]): (ClassContext, Seq[Type]) = { - val ctp = context.cls.getTypeParameters.asScala.map(tp => { + val ctp = context.cls.getTypeParameters.asScala.toSeq.map(tp => { val result = new ClassOrInterfaceType() result.setName(tp.getName) }) @@ -50,7 +51,7 @@ trait Generics[AP <: AnyParadigm] extends Gen { else arg.clone() } if (boxedArguments.nonEmpty) { - resultTpe.setTypeArguments(boxedArguments: _*) + resultTpe.setTypeArguments(boxedArguments*) } (context, resultTpe) } @@ -91,7 +92,7 @@ trait Generics[AP <: AnyParadigm] extends Gen { else arg.clone() } if (boxedArguments.nonEmpty) { - resultTpe.setTypeArguments(boxedArguments: _*) + resultTpe.setTypeArguments(boxedArguments*) } (context, resultTpe) } @@ -108,7 +109,7 @@ trait Generics[AP <: AnyParadigm] extends Gen { else arg.clone() } if (boxedArguments.nonEmpty) { - resultTpe.setTypeArguments(boxedArguments: _*) + resultTpe.setTypeArguments(boxedArguments*) } (context, resultTpe) } @@ -122,7 +123,7 @@ trait Generics[AP <: AnyParadigm] extends Gen { else arg.clone() } if (boxedArguments.nonEmpty) { - resultExp.setTypeArguments(boxedArguments: _*) + resultExp.setTypeArguments(boxedArguments*) } (context, resultExp) } @@ -143,10 +144,10 @@ object Generics { val oo: ooParadigm.type = ooParadigm val ppol: ppolyParadigm.type = ppolyParadigm - new Generics[b.type] { - val base: b.type = b - val ooParadigm: oo.type = oo - val ppolyParadigm: ppol.type = ppol - } + case class G( + override val base: b.type)( + override val ooParadigm: oo.type = oo, + override val ppolyParadigm: ppol.type = ppol) extends Generics[b.type] + return G(b)(oo, ppol) } } \ No newline at end of file diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Imperative.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Imperative.scala index f21de404..c291b11b 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Imperative.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Imperative.scala @@ -2,10 +2,10 @@ package org.combinators.ep.language.java.paradigm /*DI:LD:AI*/ import com.github.javaparser.ast.expr.{AssignExpr, NameExpr, VariableDeclarationExpr} import com.github.javaparser.ast.stmt.{BlockStmt, ExpressionStmt, IfStmt, ReturnStmt, WhileStmt} -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.IfThenElse -import org.combinators.ep.generator.paradigm.control.{Imperative => Imp, _} +import org.combinators.cogen.paradigm.IfThenElse +import org.combinators.cogen.paradigm.control.{AssignVariable, DeclareVariable, LiftExpression, Return, While, Imperative as Imp} +import org.combinators.cogen.{Command, Understands} +import org.combinators.cogen.Command.Generator import org.combinators.ep.language.java.{CtorCtxt, MethodBodyCtxt} trait Imperative[Ctxt, AP <: AnyParadigm] extends Imp[Ctxt] { diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Lambdas.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Lambdas.scala index f1b45789..6c8300cd 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Lambdas.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/Lambdas.scala @@ -1,7 +1,7 @@ package org.combinators.ep.language.java.paradigm /*DI:LD:AI*/ -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.control.{Lambdas => Lams, _} +import org.combinators.cogen.paradigm.control.Lambdas as Lams +import org.combinators.cogen.{Command, Understands} trait Lambdas[Ctxt, AP <: AnyParadigm] extends Lams[Ctxt] { diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ObjectOriented.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ObjectOriented.scala index 8b946405..263f617e 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ObjectOriented.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ObjectOriented.scala @@ -4,15 +4,15 @@ import java.util.UUID import com.github.javaparser.ast.{ImportDeclaration, Modifier, NodeList} import com.github.javaparser.ast.`type`.ClassOrInterfaceType import com.github.javaparser.ast.body.{ClassOrInterfaceDeclaration, ConstructorDeclaration, MethodDeclaration} -import com.github.javaparser.ast.expr.{AssignExpr, CastExpr, EnclosedExpr, Expression, FieldAccessExpr, InstanceOfExpr, MethodCallExpr, NameExpr, ObjectCreationExpr, ThisExpr, TypeExpr, Name => JName} +import com.github.javaparser.ast.expr.{AssignExpr, CastExpr, EnclosedExpr, Expression => JExpression, FieldAccessExpr, InstanceOfExpr, MethodCallExpr, NameExpr, ObjectCreationExpr, ThisExpr, TypeExpr, Name as JName} import com.github.javaparser.ast.stmt.{BlockStmt, ExplicitConstructorInvocationStmt, ExpressionStmt, ReturnStmt} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{ObjectOriented => OO, AnyParadigm => _, _} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{AddBlockDefinitions, AddClass, AddConstructor, AddField, AddImplemented, AddImport, AddMethod, AddParent, AddTypeLookup, Apply, CastObject, Debug, FindClass, FreshName, GetArguments, GetConstructor, GetField, GetMember, InitializeField, InitializeParent, InstanceOfType, InstantiateObject, Reify, RemoveMethod, ResolveImport, SelfReference, SetAbstract, SetInterface, SetOverride, SetParameters, SetStatic, SuperReference, ToTargetLanguageType, ObjectOriented as OO} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.Syntax.MangledName -import org.combinators.ep.language.java.{ClassCtxt, CompilationUnitCtxt, ContextSpecificResolver, CtorCtxt, JavaNameProvider, MethodBodyCtxt, TestCtxt} +import org.combinators.ep.language.java.{ClassCtxt, ContextSpecificResolver, CtorCtxt, JavaNameProvider, MethodBodyCtxt, TestCtxt} import scala.util.Try import scala.jdk.CollectionConverters._ @@ -39,7 +39,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { val (resultCtxt, _) = Command.runGenerator( command.cls, - ClassCtxt(context.resolver, clsToAdd, context.unit.getImports.asScala) + ClassCtxt(context.resolver, clsToAdd, context.unit.getImports.asScala.toSeq) ) val newUnit = context.unit.clone() newUnit.addType(resultCtxt.cls) @@ -172,7 +172,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { val resultCls = context.cls.clone() val modifiers: Seq[Modifier.Keyword] = (if (command.isVisibleToSubclasses) Seq(Modifier.protectedModifier().getKeyword) else Seq(Modifier.privateModifier().getKeyword)) ++ (if (command.isMutable) Seq.empty else Seq(Modifier.finalModifier().getKeyword)) - resultCls.addField(command.tpe, command.name.toAST.toString, modifiers:_*) + resultCls.addField(command.tpe, command.name.toAST.toString, modifiers*) (context.copy(cls = resultCls), ()) } } @@ -441,7 +441,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { /** Expand with instantiated body (if it exists). */ val result = new ObjectCreationExpr() result.setType(tpe.asClassOrInterfaceType().clone()) - result.setArguments(new NodeList(args : _*)) + result.setArguments(new NodeList(args*)) if (command.body.isDefined) { val ci = new ClassOrInterfaceDeclaration() val (newCtxt, classDef) = Command.runGenerator(command.body.get, ClassCtxt(context.resolver, ci, context.extraImports)) @@ -471,7 +471,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { command.arguments.foreach(arg => result.addArgument(arg.clone())) (context, result) } else { - val result = new MethodCallExpr(command.functional.toString, command.arguments:_*) + val result = new MethodCallExpr(command.functional.toString, command.arguments*) (context, result) } } @@ -512,7 +512,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { context: ConstructorContext, command: GetArguments[Type, Name, Expression] ): (ConstructorContext, Seq[(Name, Type, Expression)]) = { - val args = context.ctor.getParameters.asScala.map { param => + val args = context.ctor.getParameters.asScala.toSeq.map { param => (MangledName.fromAST(param.getName), param.getType.clone(), new NameExpr(param.getName.clone())) } (context, args) @@ -601,7 +601,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { /** Expand with instantiated body (if it exists). */ val result = new ObjectCreationExpr() result.setType(tpe.asClassOrInterfaceType().clone()) - result.setArguments(new NodeList(args : _*)) + result.setArguments(new NodeList(args*)) if (command.body.isDefined) { val ci = new ClassOrInterfaceDeclaration() val (newCtxt, classDef) = Command.runGenerator(command.body.get, ClassCtxt(context.resolver, ci, context.extraImports)) @@ -813,9 +813,9 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { (if (command.isVisibleToSubclasses) Seq(Modifier.protectedModifier().getKeyword) else Seq(Modifier.privateModifier().getKeyword)) ++ (if (command.isMutable) Seq.empty else Seq(Modifier.finalModifier().getKeyword)) if (command.initializer.isDefined) { - resultCls.addFieldWithInitializer(command.tpe, command.name.toAST.toString, expr, modifiers: _*) + resultCls.addFieldWithInitializer(command.tpe, command.name.toAST.toString, expr, modifiers*) } else { - resultCls.addField(command.tpe, command.name.toAST.toString, modifiers: _*) + resultCls.addField(command.tpe, command.name.toAST.toString, modifiers*) } (context.copy(testClass = resultCls), ()) @@ -863,7 +863,7 @@ trait ObjectOriented[AP <: AnyParadigm] extends OO { /** REMOVED [Expand with instantiated body (if it exists).] */ val result = new ObjectCreationExpr() result.setType(tpe.asClassOrInterfaceType().clone()) - result.setArguments(new NodeList(args : _*)) + result.setArguments(new NodeList(args*)) (context, result) } } @@ -968,10 +968,10 @@ object ObjectOriented { rest.foldLeft(new JName(first))((result, next) => new JName(result, next)) } - def nameToExpression(name: JName): Expression = { + def nameToExpression(name: JName): JExpression = { name.getQualifier - .map[Expression](n => nameToExpression(n)) - .map[Expression](qual => new FieldAccessExpr(qual, name.getIdentifier)) + .map[JExpression](n => nameToExpression(n)) + .map[JExpression](qual => new FieldAccessExpr(qual, name.getIdentifier)) .orElseGet(() => new NameExpr(name.getIdentifier)) } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ParametricPolymorphism.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ParametricPolymorphism.scala index 86c27db7..293f3051 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ParametricPolymorphism.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ParametricPolymorphism.scala @@ -2,8 +2,8 @@ package org.combinators.ep.language.java.paradigm /*DI:LD:AI*/ import com.github.javaparser.ast.`type`.{ClassOrInterfaceType, TypeParameter} import com.github.javaparser.ast.expr.MethodCallExpr -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{ParametricPolymorphism => PPoly, _} +import org.combinators.cogen.paradigm.{AddTypeParameter, Apply, GetTypeArguments, ParametricPolymorphism as PPoly, AnyParadigm as _} +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.Syntax.MangledName import org.combinators.ep.language.java.TypeParamCtxt @@ -34,7 +34,7 @@ trait ParametricPolymorphism[AP <: AnyParadigm] extends PPoly { implicit val canGetTypeArgumentsInMethod: Understands[MethodBodyContext, GetTypeArguments[Type]] = new Understands[MethodBodyContext, GetTypeArguments[Type]] { def perform(context: MethodBodyContext, command: GetTypeArguments[Type]): (MethodBodyContext, Seq[Type]) = { - val ctp = context.method.getTypeParameters.asScala.map(tp => { + val ctp = context.method.getTypeParameters.asScala.toSeq.map(tp => { val result = new ClassOrInterfaceType() result.setName(tp.getName) }) @@ -50,7 +50,7 @@ trait ParametricPolymorphism[AP <: AnyParadigm] extends PPoly { else arg.clone() } if (boxedArguments.nonEmpty) { - resultTpe.setTypeArguments(boxedArguments: _*) + resultTpe.setTypeArguments(boxedArguments*) } (context, resultTpe) } @@ -75,7 +75,7 @@ trait ParametricPolymorphism[AP <: AnyParadigm] extends PPoly { else arg.clone() } if (boxedArguments.nonEmpty) { - resultExp.setTypeArguments(boxedArguments: _*) + resultExp.setTypeArguments(boxedArguments*) } (context, resultExp) } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arithmetic.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arithmetic.scala index 9ed862db..63769ffb 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arithmetic.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arithmetic.scala @@ -1,11 +1,11 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.expr.BinaryExpr -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Add, Div, LE, LT, Mod, Mult, Sub, Arithmetic => Arith} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Add, Div, LE, LT, Mod, Mult, Sub, Arithmetic as Arith} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.Understands import org.combinators.ep.language.java.paradigm.AnyParadigm import org.combinators.ep.language.java.{ContextSpecificResolver, ProjectCtxt} import org.combinators.ep.language.java.Syntax.default._ diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arrays.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arrays.scala index 24b536f5..b9adf1a0 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arrays.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Arrays.scala @@ -2,17 +2,17 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.`type`.ArrayType import com.github.javaparser.ast.expr.{ArrayAccessExpr, ArrayCreationExpr, ArrayInitializerExpr, AssignExpr, FieldAccessExpr, IntegerLiteralExpr, MethodCallExpr, NameExpr, SimpleName} -import com.github.javaparser.ast.{ArrayCreationLevel, ImportDeclaration, NodeList} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax._ -import org.combinators.ep.generator.paradigm.ffi.{Arrays => Arrs, _} -import org.combinators.ep.generator.paradigm.{AddImport, Apply} -import org.combinators.ep.generator.{Command, Understands} +import com.github.javaparser.ast.{ArrayCreationLevel, NodeList} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{Apply, ffi} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.AnyParadigm.syntax._ +import org.combinators.cogen.paradigm.ffi.{CreateArray, Get, Length, Arrays as Arrs} +import org.combinators.cogen.Understands import org.combinators.ep.language.java.CodeGenerator.Enable import org.combinators.ep.language.java.Syntax.default._ -import org.combinators.ep.language.java.paradigm.{AnyParadigm, Generics, ObjectOriented} +import org.combinators.ep.language.java.paradigm.AnyParadigm import org.combinators.ep.language.java.{ContextSpecificResolver, ProjectCtxt} class Arrays[Ctxt, AP <: AnyParadigm](val base:AP) extends Arrs[Ctxt] { @@ -27,7 +27,7 @@ class Arrays[Ctxt, AP <: AnyParadigm](val base:AP) extends Arrs[Ctxt] { (context, new ArrayCreationExpr(command.functional.elementType, new NodeList(new ArrayCreationLevel(1)), - new ArrayInitializerExpr(new NodeList(command.arguments: _ *))) + new ArrayInitializerExpr(new NodeList(command.arguments*))) ) } @@ -46,11 +46,11 @@ class Arrays[Ctxt, AP <: AnyParadigm](val base:AP) extends Arrs[Ctxt] { } } - implicit val canSet: Understands[Ctxt, Apply[Set, Expression, Expression]] = - new Understands[Ctxt, Apply[Set, Expression, Expression]] { + implicit val canSet: Understands[Ctxt, Apply[ffi.Set, Expression, Expression]] = + new Understands[Ctxt, Apply[ffi.Set, Expression, Expression]] { override def perform( context: Ctxt, - command: Apply[Set, Expression, Expression] + command: Apply[ffi.Set, Expression, Expression] ): (Ctxt, Expression) = { (context, new AssignExpr(new ArrayAccessExpr(command.arguments(0), command.arguments(1)), command.arguments(2), AssignExpr.Operator.ASSIGN)) } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Assertions.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Assertions.scala index d479d719..dc4be600 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Assertions.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Assertions.scala @@ -3,11 +3,11 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.ImportDeclaration import com.github.javaparser.ast.`type`.PrimitiveType import com.github.javaparser.ast.expr.{BooleanLiteralExpr, NameExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Assert, Assertions => Assrts} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Assert, Assertions as Assrts} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.paradigm.{AnyParadigm, ObjectOriented} import org.combinators.ep.language.java.{ContextSpecificResolver, JavaNameProvider, MethodBodyCtxt, ProjectCtxt} import org.combinators.ep.language.java.Syntax.default._ diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Booleans.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Booleans.scala index 2992d3cb..538e4fee 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Booleans.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Booleans.scala @@ -1,16 +1,16 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.expr.{BinaryExpr, BooleanLiteralExpr, UnaryExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.Understands -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Booleans => Bools, _} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.Understands import org.combinators.ep.language.java.paradigm.AnyParadigm import org.combinators.ep.language.java.{ContextSpecificResolver, OperatorExprs, ProjectCtxt, Syntax} import org.combinators.ep.language.java.CodeGenerator.Enable import Syntax.default._ import com.github.javaparser.ast.`type`.PrimitiveType +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{And, False, Not, Or, True, Booleans as Bools} class Booleans[Ctxt, AP <: AnyParadigm](val base: AP) extends Bools[Ctxt] { diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Console.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Console.scala index bbb35e3f..946965e8 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Console.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Console.scala @@ -2,10 +2,10 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.NodeList import com.github.javaparser.ast.expr.{FieldAccessExpr, MethodCallExpr, NameExpr, SimpleName} -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.ffi.{Console => Con, _} -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator. Understands +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Print, Strings, Console as Con} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.Understands import org.combinators.ep.language.java.Syntax.default._ import org.combinators.ep.language.java.paradigm.AnyParadigm diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Equality.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Equality.scala index 5cc4b3cd..9224e793 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Equality.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Equality.scala @@ -3,13 +3,13 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.NodeList import com.github.javaparser.ast.`type`.PrimitiveType import com.github.javaparser.ast.expr.{BinaryExpr, BooleanLiteralExpr, MethodCallExpr, TypeExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{Apply, GetMember} -import org.combinators.ep.generator.paradigm.ffi.{Equals, Equality => Eql} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.ffi.{Equals, Equality as Eql} +import org.combinators.cogen.paradigm.{Apply, GetMember} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.{ContextSpecificResolver, JavaNameProvider, ProjectCtxt} -import org.combinators.ep.language.java.paradigm.{AnyParadigm, ffi} +import org.combinators.ep.language.java.paradigm.AnyParadigm import org.combinators.ep.language.java.Syntax.default._ import org.combinators.ep.language.java.CodeGenerator.Enable diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Exceptions.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Exceptions.scala index e9912724..6dae5d82 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Exceptions.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Exceptions.scala @@ -1,16 +1,16 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ -import com.github.javaparser.ast.{ImportDeclaration, NodeList} -import com.github.javaparser.ast.expr.{BooleanLiteralExpr, ObjectCreationExpr} +import com.github.javaparser.ast.NodeList +import com.github.javaparser.ast.expr.ObjectCreationExpr import com.github.javaparser.ast.stmt.ThrowStmt -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.{Apply, ffi} -import org.combinators.ep.generator.paradigm.ffi.{Assert, Exceptions => Excptns} -import org.combinators.ep.generator.{Command, Understands} +import org.combinators.cogen.paradigm.ffi +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.ffi.{Assert, Exceptions as Excptns} +import org.combinators.cogen.Understands import org.combinators.ep.language.java.CodeGenerator.Enable import org.combinators.ep.language.java.Syntax.default._ import org.combinators.ep.language.java.paradigm.{AnyParadigm, ObjectOriented} -import org.combinators.ep.language.java.{ContextSpecificResolver, MethodBodyCtxt, ProjectCtxt} +import org.combinators.ep.language.java.{MethodBodyCtxt, ProjectCtxt} class Exceptions[AP <: AnyParadigm](val base: AP) extends Excptns[MethodBodyCtxt] { diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Lists.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Lists.scala index 2f9323a0..1b7d2150 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Lists.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Lists.scala @@ -1,20 +1,18 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ -import com.github.javaparser.ast.expr.{BinaryExpr, IntegerLiteralExpr, MethodCallExpr, StringLiteralExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.instances.InstanceRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{AddImport, Apply, GetMember} -import org.combinators.ep.generator.paradigm.ffi.{Lists => Lsts, _} +import com.github.javaparser.ast.expr.{IntegerLiteralExpr, MethodCallExpr} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.CodeGenerator.Enable -import org.combinators.ep.language.java.{CodeGenerator, ContextSpecificResolver, CtorCtxt, JavaNameProvider, MethodBodyCtxt, ProjectCtxt, Syntax} +import org.combinators.ep.language.java.{ContextSpecificResolver, ProjectCtxt} import org.combinators.ep.language.java.paradigm.{AnyParadigm, Generics, ObjectOriented} import org.combinators.ep.language.java.Syntax.default._ -import org.combinators.ep.generator.paradigm.AnyParadigm.syntax._ -import cats.syntax._ -import cats.implicits._ +import org.combinators.cogen.paradigm.AnyParadigm.syntax._ import com.github.javaparser.ast.{ImportDeclaration, NodeList} +import org.combinators.cogen.InstanceRep +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.ffi.{Append, Cons, Create, Head, Tail, Lists as Lsts} +import org.combinators.cogen.paradigm.{AddImport, Apply} trait Lists[Ctxt, AP <: AnyParadigm] extends Lsts[Ctxt] { case object ListsEnabled @@ -61,7 +59,7 @@ trait Lists[Ctxt, AP <: AnyParadigm] extends Lsts[Ctxt] { } else { for { _ <- AddImport[Import](new ImportDeclaration("java.util.Arrays", false, false)).interpret(canAddImport) - } yield new MethodCallExpr(ObjectOriented.nameToExpression(ObjectOriented.fromComponents("java", "util", "Arrays")), "asList", new NodeList[Expression](command.arguments:_*)) + } yield new MethodCallExpr(ObjectOriented.nameToExpression(ObjectOriented.fromComponents("java", "util", "Arrays")), "asList", new NodeList[Expression](command.arguments*)) } Command.runGenerator[Ctxt, Expression](gen, context) } @@ -253,28 +251,23 @@ object Lists { type Aux[Ctxt, AP <: AnyParadigm, Gen <: Generics[AP]] = Lists[Ctxt, AP] { val generics: Gen } - def apply[Ctxt, AP <: AnyParadigm, Gen <: Generics[AP]]( + def apply[Ctxt, AP <: AnyParadigm, Gen[A <: AP] <: Generics[A]]( base: AP, - getMember: Understands[Ctxt, GetMember[Expression, Name]], - applyMethod: Understands[Ctxt, Apply[Expression, Expression, Expression]], applyType: Understands[Ctxt, Apply[Type, Type, Type]], addImport: Understands[Ctxt, AddImport[Import]])( - generics: Generics[base.type] + generics: Gen[base.type] ): Aux[Ctxt, base.type, generics.type] = { val b: base.type = base - val gm = getMember - val appMeth = applyMethod val appTy = applyType val addImp = addImport val gen: generics.type = generics - new Lists[Ctxt, b.type] { - lazy val base: b.type = b - lazy val getMember = gm - lazy val applyMethod = appMeth - lazy val applyType = appTy - lazy val addImport = addImp - lazy val generics: gen.type = gen - } + case class Lsts(override val base: b.type, + override val applyType: Understands[Ctxt, Apply[Type, Type, Type]], + override val addImport: Understands[Ctxt, AddImport[Import]], + override val generics: gen.type + ) extends Lists[Ctxt, b.type] + + Lsts(b, appTy, addImp, gen) } } \ No newline at end of file diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/RealArithmetic.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/RealArithmetic.scala index ec6271c2..bbd9ffc8 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/RealArithmetic.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/RealArithmetic.scala @@ -3,11 +3,11 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.NodeList import com.github.javaparser.ast.expr.BinaryExpr.Operator import com.github.javaparser.ast.expr.{BinaryExpr, Expression, FieldAccessExpr, MethodCallExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.Apply -import org.combinators.ep.generator.paradigm.ffi.{Abs, Cos, EulersNumber, Floor, Log, Pi, Pow, Sin, Sqrt, RealArithmetic => RArith} +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.Apply +import org.combinators.cogen.paradigm.ffi.{Abs, Cos, EulersNumber, Floor, Log, Pi, Pow, Sin, Sqrt, RealArithmetic as RArith} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.CodeGenerator.Enable import org.combinators.ep.language.java.Syntax.default._ import org.combinators.ep.language.java.paradigm.{AnyParadigm, ObjectOriented} @@ -33,7 +33,7 @@ class RealArithmetic[Ctxt, T, AP <: AnyParadigm]( context: Ctxt, command: Apply[Op, Expression, Expression] ): (Ctxt, Expression) = { - (context, new MethodCallExpr(mathExp, methodName, new NodeList[Expression](command.arguments: _*))) + (context, new MethodCallExpr(mathExp, methodName, new NodeList[Expression](command.arguments*))) } } diff --git a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Strings.scala b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Strings.scala index 075a1743..5e62ad55 100644 --- a/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Strings.scala +++ b/language/java/src/main/scala/org/combinators/ep/language/java/paradigm/ffi/Strings.scala @@ -1,16 +1,16 @@ package org.combinators.ep.language.java.paradigm.ffi /*DI:LD:AI*/ import com.github.javaparser.ast.expr.{BinaryExpr, MethodCallExpr, StringLiteralExpr} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.{Command, Understands} -import org.combinators.ep.generator.paradigm.{Apply, GetMember} -import org.combinators.ep.generator.paradigm.ffi.{Strings => Strs, _} +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.{Command, Understands} import org.combinators.ep.language.java.{CodeGenerator, ContextSpecificResolver, JavaNameProvider, ProjectCtxt, Syntax} import Syntax.default._ import org.combinators.ep.language.java.paradigm.{AnyParadigm, ObjectOriented} import CodeGenerator.Enable import com.github.javaparser.ast.NodeList +import org.combinators.cogen.TypeRep +import org.combinators.cogen.paradigm.{Apply, GetMember} +import org.combinators.cogen.paradigm.ffi.{GetStringLength, StringAppend, ToString, Strings as Strs} class Strings[Ctxt, AP <: AnyParadigm]( val base: AP, diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala deleted file mode 100644 index 36e86342..00000000 --- a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ScalaNameProvider.scala +++ /dev/null @@ -1,51 +0,0 @@ -package org.combinators.ep.language.scala /*DI:LD:AI*/ - -import com.github.javaparser.{JavaParser, StaticJavaParser} -import org.combinators.ep.generator.NameProvider -import org.combinators.ep.language.inbetween.any - -import scala.util.Try - -/** Provides name mangling for Java */ -class ScalaNameProvider[FT <: FinalTypes](factory: Factory[FT]) extends NameProvider[any.Name[FT]] { - val parser = new JavaParser(StaticJavaParser.getConfiguration) - - /** Need to have single-param version so this can be used in map. */ - def mangle(name: String): any.Name[FT] = { - mangle(name, Set("Object", "hashCode", "equals", "toString", "getClass", "type")) - } - - /** Tries to parse names as a - * [[https://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.2 simple Java name]] and mangles to - * the arabic number representation of the UTF-8 bytes in the given string, where each byte is prefixed by "_". - * - * Example: - * {{ - * JavaNameProvider.mangle("foo") // returns "foo" - * JavaNameProvider.mangle("class") // returns "_99_108_97_115_115" because "class" is a reserved keyword - * }} - */ - def mangle(name: String, forbidden:Set[String]): any.Name[FT] = { - var cleanName = name - - // some default methods in java.lang.Object CANNOT be overridden as needed by some AIPs, so - // take steps to avoid special java methods. To ensure 'equals' and other FFI-required names - // go through unchanged, we allow for optional parameter to eliminate. - while (forbidden.contains(cleanName)) { - cleanName = "_" + cleanName - } - - factory.name(name, Try(parser.parseSimpleName(cleanName).getResult.map[String](_.getIdentifier).get).getOrElse { - cleanName.getBytes(java.nio.charset.StandardCharsets.UTF_8).mkString("_", "_", "") - } - ) - } - - def addPrefix(prefix: String, name: any.Name[FT]): any.Name[FT] = { - mangle(prefix + factory.convert(name).component) - } - - def addSuffix(name: any.Name[FT], suffix: String): any.Name[FT] = { - mangle(factory.convert(name).component + suffix) - } -} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/BaseAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/BaseAST.scala new file mode 100644 index 00000000..c072a900 --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/BaseAST.scala @@ -0,0 +1,1886 @@ +package org.combinators.ep.language.scala.ast + +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.TypeRep.OfHostType +import org.combinators.cogen.{FileWithPath, NameProvider, TypeRep} +import org.combinators.ep.language.inbetween.functional +import org.combinators.ep.language.inbetween.functional.FunctionalAST +import org.combinators.ep.language.inbetween.functional.control.FunctionalControlAST +import org.combinators.ep.language.inbetween.imperative.ImperativeAST +import org.combinators.ep.language.inbetween.oo.OOAST +import org.combinators.ep.language.inbetween.polymorphism.generics.GenericsAST + +import java.util.UUID + + +trait BaseAST extends OOAST with FunctionalAST with GenericsAST with FunctionalControlAST with ImperativeAST with NameProviderAST { + object scalaBase { + object anyOverrides { + trait FinalTypes extends oo.anyOverrides.FinalTypes + with functional.anyOverrides.FinalTypes + with funcontrol.anyOverrides.FinalTypes + with generics.anyOverrides.FinalTypes { + type Project <: anyOverrides.Project + type CompilationUnit <: anyOverrides.CompilationUnit + type Method <: anyOverrides.Method + type Expression <: anyOverrides.Expression + type TestSuite <: anyOverrides.TestSuite + type Import <: anyOverrides.Import + type Statement <: anyOverrides.Statement + type Type <: anyOverrides.Type + type Name <: anyOverrides.Name + type ApplyExpression <: anyOverrides.ApplyExpression + type ArgumentExpression <: anyOverrides.ArgumentExpression + } + + trait Project extends oo.anyOverrides.Project with functional.anyOverrides.Project { + import factory.* + + override def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method, any.Type]]): any.Project = { + super.addTypeLookupsForMethods(lookups).addTypeLookupsForFunctions(lookups) + } + + def copyAsScalaProject( + compilationUnits: Set[any.CompilationUnit] = this.compilationUnits, + customFiles: Seq[FileWithPath] = this.customFiles, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = this.constructorTypeLookupMap, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = this.classTypeLookupMap, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = this.adtTypeLookupMap, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.functionTypeLookupMap, + ): anyOverrides.Project = scalaBaseFactory.scalaProject( + compilationUnits, + customFiles, + methodTypeLookupMap, + constructorTypeLookupMap, + classTypeLookupMap, + adtTypeLookupMap, + functionTypeLookupMap + ) + + override def copyAsProjectWithTypeLookups( + compilationUnits: Set[any.CompilationUnit] = this.compilationUnits, + customFiles: Seq[FileWithPath] = this.customFiles, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = this.constructorTypeLookupMap, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = this.classTypeLookupMap + ): anyOverrides.Project = + copyAsScalaProject( + compilationUnits = compilationUnits, + customFiles = customFiles, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + classTypeLookupMap = classTypeLookupMap + ) + + override def copyAsFunctionalProject( + compilationUnits: Set[any.CompilationUnit] = this.compilationUnits, + customFiles: Seq[FileWithPath] = this.customFiles, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = this.adtTypeLookupMap, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.functionTypeLookupMap, + ): anyOverrides.Project = + copyAsScalaProject( + compilationUnits = compilationUnits, + customFiles = customFiles, + adtTypeLookupMap = adtTypeLookupMap, + functionTypeLookupMap = functionTypeLookupMap, + ) + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Project = + copyAsScalaProject( + compilationUnits = compilationUnits.map(cu => convert(cu).prefixRootPackage(rootPackageName, excludedTypeNames)), + methodTypeLookupMap = tpeRep => methodTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + classTypeLookupMap = tpeRep => classTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + adtTypeLookupMap = tpeRep => adtTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + functionTypeLookupMap = tpeRep => functionTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + ) + } + + trait CompilationUnit extends oo.anyOverrides.CompilationUnit with functional.anyOverrides.CompilationUnit with Util { + import factory.* + import functionalFactory.* + import ooFactory.* + + def toScala: String = { + val importDecls = imports.map(_.toScala).mkString("\n ") + val adtsDecl = adts.map(_.toScala).mkString("\n\n") + val clsDecls = classes.map(_.toScala).mkString("\n\n") + val testDecls = tests.map(_.toScala).mkString("\n\n") + val packageDecl = if (name.init.isEmpty) "" else s"package ${name.init.map(_.toScala).mkString(".")}" + val functionsDecl = functions.map(fun => { + fun.copyAsClsMethod(isPublic = true).toScala + }).mkString("\n\n") + + s""" + |$packageDecl + |$importDecls + |$adtsDecl + |$clsDecls + |$functionsDecl + |$testDecls + |""".stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.CompilationUnit = { + copyAsScalaCompilationUnit( + name = rootPackageName ++ name, + imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + methodTypeLookupMap = tpeRep => methodTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + classTypeLookupMap = tpeRep => classTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + adtTypeLookupMap = tpeRep => adtTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + functionTypeLookupMap = tpeRep => functionTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + classes = classes.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + adts = adts.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + functions = functions.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + tests = tests.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + ) + } + + def copyAsScalaCompilationUnit( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = this.constructorTypeLookupMap, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = this.classTypeLookupMap, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = this.adtTypeLookupMap, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.functionTypeLookupMap, + classes: Seq[oo.Class] = this.classes, + adts: Seq[functional.AlgebraicDataType] = this.adts, + functions: Seq[any.Method] = this.functions, + tests: Seq[any.TestSuite] = this.tests, + ): anyOverrides.CompilationUnit = + scalaBaseFactory.scalaCompilationUnit( + name, + imports, + methodTypeLookupMap, + constructorTypeLookupMap, + classTypeLookupMap, + adtTypeLookupMap, + functionTypeLookupMap, + classes, + adts, + functions, + tests) + + override def copyAsCompilationUnitWithClasses( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.methodTypeLookupMap, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = this.constructorTypeLookupMap, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = this.classTypeLookupMap, + classes: Seq[oo.Class] = this.classes, + tests: Seq[any.TestSuite] = this.tests, + ): anyOverrides.CompilationUnit = + copyAsScalaCompilationUnit( + name = name, + imports = imports, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + classTypeLookupMap = classTypeLookupMap, + classes = classes, + tests = tests) + + override def copyAsFunctionalCompilationUnit( + name: Seq[any.Name] = this.name, + imports: Seq[any.Import] = this.imports, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = this.adtTypeLookupMap, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = this.functionTypeLookupMap, + adts: Seq[functional.AlgebraicDataType] = this.adts, + functions: Seq[any.Method] = this.functions, + tests: Seq[any.TestSuite] = this.tests, + ): anyOverrides.CompilationUnit = copyAsScalaCompilationUnit( + name = name, + imports = imports, + adtTypeLookupMap = adtTypeLookupMap, + functionTypeLookupMap = functionTypeLookupMap, + adts = adts, + functions = functions, + tests = tests) + + override def initializeInProject(project: any.Project): any.CompilationUnit = { + val withLookups = copyAsScalaCompilationUnit( + adtTypeLookupMap = project.adtTypeLookupMap, + functionTypeLookupMap = project.functionTypeLookupMap, + methodTypeLookupMap = project.methodTypeLookupMap, + constructorTypeLookupMap = project.constructorTypeLookupMap, + classTypeLookupMap = project.classTypeLookupMap, + ) + withLookups.copyAsScalaCompilationUnit( + tests = withLookups.tests.map(_.initializeInCompilationUnit(withLookups)) + ) + } + + } + + trait Method extends generics.anyOverrides.Method + with functional.anyOverrides.Method + with funcontrol.anyOverrides.Method + with Util { + import factory.* + import imperativeFactory.* + import polymorphismFactory.* + + override def emptyPatternCtxt: funcontrol.PatternContext = functionalControlFactory.patternContext(Seq.empty) + + def addTestExpressions(exprs: Seq[any.Expression]): any.Method = { + copy(statements = exprs.map(liftExpression)) + } + + def findClass(qualifiedName: any.Name*): any.Type = + ooFactory.classReferenceType(qualifiedName *) + + def findMethod(qualifiedName: Seq[any.Name]): any.Expression = + scalaBaseFactory.methodReferenceExpression(qualifiedName) + + def toScala: String = { + val overrideMod = if (isOverride) "override" else "" + val privateMod = if (!isPublic) "private" else "" + val mods = Seq(overrideMod, privateMod).mkString(" ") + + val params = parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString(",") + val typeParams = if (typeParameters.isEmpty) "" else typeParameters.map(_.toScala).mkString("[", ",", "]") + val returnTpe = returnType.map(_.toScala).getOrElse("Unit") + val body = if (!isAbstract) { + s"""= { + | ${imports.map(_.toScala).mkString("\n ")} + | ${statements.map(_.toScala).mkString("\n ")} + |} + """.stripMargin + } else "" + + s"""$mods def ${name.toScala}$typeParams($params): $returnTpe $body""".stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Method = { + copyAsGenericMethod( + name = name, + imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + statements = statements.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + returnType = returnType.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + typeParameters = typeParameters.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + parameters = parameters.map { case (name, tpe) => (name, tpe.prefixRootPackage(rootPackageName, excludedTypeNames)) }, + typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + } + + trait Expression extends oo.anyOverrides.Expression { + def toScala: String + + def isTypeReferenceExpression: Boolean = false + + def toImport: Seq[any.Import] = Seq.empty + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Expression + } + + trait TestSuite extends oo.anyOverrides.TestSuite with Util { + import factory.* + import imperativeFactory.* + import ooFactory.* + import scalaBaseFactory.* + + def inFunSuiteStyle: oo.Class = { + val withFunSuiteExtension = + underlyingClass.addParent(classReferenceType( + Seq("org", "scalatest", "funsuite", "AnyFunSuite").map(n => nameProvider.mangle(n)) * + )) + val methodsAsTests = withFunSuiteExtension.methods.zip(this.testMarkers).filter { case (m, isTest) => isTest }.map { case (m, _) => { + liftExpression(applyExpression( + applyExpression( + memberAccessExpression(selfReferenceExpression, nameProvider.mangle("test")), + Seq(reifiedScalaValue(TypeRep.String, m.name.component)) + ), + Seq(blockExpression(m.statements)) + )) + } + } + val withPrimaryClsConstructor = if (underlyingClass.constructors.isEmpty) { + withFunSuiteExtension.addConstructor(constructor(statements = methodsAsTests)) + } else { + val updatedPrimary = underlyingClass.constructors.head.copyAsConstructor( + statements = underlyingClass.constructors.head.statements ++ methodsAsTests + ) + withFunSuiteExtension.copy(constructors = updatedPrimary +: underlyingClass.constructors.tail) + } + val helperMethods = withPrimaryClsConstructor.methods.zip(testMarkers).filter { case (_, isTest) => !isTest }.map(_._1) + + withPrimaryClsConstructor.copy(methods = helperMethods) + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.TestSuite = { + copyAsClassBasedTestSuite(underlyingClass = underlyingClass.prefixRootPackage(rootPackageName, excludedTypeNames)) + } + + def toScala: String = inFunSuiteStyle.toScala + } + + trait Import extends any.Import { + import factory.* + + def components: Seq[any.Name] + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Import = { + if (excludedTypeNames.contains(components)) { + this + } else { + copy(components = rootPackageName ++ components) + } + } + + def toScala: String = + s"""import ${components.map(_.toScala).mkString(".")}""" + + def copy(components: Seq[any.Name] = this.components): any.Import = + scalaBaseFactory.importStatement(components) + } + + trait Statement extends any.Statement { + def toScala: String + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Statement + } + + trait Type extends any.Type { + def toScala: String + def toImport: Seq[any.Import] + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Type + } + + trait Name extends any.Name { + def component: String + def mangled: String + def toScala: String = mangled + } + + trait ApplyExpression extends Expression with any.ApplyExpression { + import factory.* + def toScala: String = { + val (typeArguments, regularArguments) = arguments.partition(_.isTypeReferenceExpression) + + // If Type arguments, then emit those without the arguments, which appear to come later + if (typeArguments.nonEmpty) { + val tyArgs = typeArguments.map(_.toScala).mkString("[", ", ", "]") + s"${function.toScala}$tyArgs" + } else { + val args = if (regularArguments.isEmpty) "()" else regularArguments.map(_.toScala).mkString("(", ", ", ")") + s"${function.toScala}$args" + } + + //val result = s"${function.toScala}${tyArgs}${args}" + //result + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.ApplyExpression = { + copy( + function = function.prefixRootPackage(rootPackageName, excludedTypeNames), + arguments = arguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + } + + trait ArgumentExpression extends Expression with any.ArgumentExpression { + import factory.* + def toScala: String = s"${parameterName.toScala}" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.ArgumentExpression = + this + } + + trait Return extends Statement with any.Return { + import factory.* + def toScala: String = s"return { ${this.expression.toScala.stripLeading()} }" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Return = + copy( + expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait Factory extends oo.anyOverrides.Factory + with functional.anyOverrides.Factory + with generics.anyOverrides.Factory {} + } + + object functionalOverrides { + trait FinalTypes extends functional.FinalTypes { + type AlgebraicDataType <: functionalOverrides.AlgebraicDataType + type TypeConstructor <: functionalOverrides.TypeConstructor + type TypeInstantiationExpression <: functionalOverrides.TypeInstantiationExpression + type ADTReferenceType <: functionalOverrides.ADTReferenceType + } + + trait AlgebraicDataType extends functional.AlgebraicDataType with anyOverrides.Type with Util { + import factory.* + import functionalFactory.* + + override def toImport: Seq[any.Import] = Seq.empty + + def toScala: String = { + val ctors = this.typeConstructors.map(_.toScala).mkString("\n ") + s""" + |enum ${this.name.toScala} { + | $ctors + |}""".stripMargin + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): AlgebraicDataType = + copy( + imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + typeConstructors = typeConstructors.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + ) + } + + trait TypeConstructor extends functional.TypeConstructor { + import factory.* + + def toScala: String = { + val params = parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString(",") + s"""case ${name.toScala}($params)""" + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): functional.TypeConstructor = { + copy(parameters = this.parameters.map(p => (p._1, p._2.prefixRootPackage(rootPackageName, excludedTypeNames)))) + } + } + + trait TypeInstantiationExpression extends functional.TypeInstantiationExpression with anyOverrides.Expression { + import factory.* + + override def toScala: String = { + s"""${tpe.toScala}.${constructorName.map(_.toScala).mkString(".")}(${constructorArguments.map(_.toScala).mkString(", ")})""".stripMargin + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): functional.TypeInstantiationExpression = + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + constructorArguments = constructorArguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + + trait ADTReferenceType extends functional.ADTReferenceType with anyOverrides.Type { + import factory.* + + def toScala: String = qualifiedTypeName.map(_.toScala).mkString(".") + + def toImport: Seq[any.Import] = Seq.empty + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): functional.ADTReferenceType = { + if (excludedTypeNames.contains(qualifiedTypeName)) { + this + } else { + copy( + qualifiedTypeName = rootPackageName ++ qualifiedTypeName + ) + } + } + } + + trait Factory extends functional.Factory { + override def functionalProject( + compilationUnits: Set[any.CompilationUnit], + customFiles: Seq[FileWithPath] = Seq.empty, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + ): anyOverrides.Project = scalaBaseFactory.scalaProject( + compilationUnits = compilationUnits, + customFiles = customFiles, + adtTypeLookupMap = adtTypeLookupMap, + functionTypeLookupMap = functionTypeLookupMap, + methodTypeLookupMap = Map.empty, + constructorTypeLookupMap = Map.empty, + classTypeLookupMap = Map.empty, + ) + + override def funCompilationUnit( + name: Seq[any.Name], + imports: Seq[any.Import], + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + adts: Seq[functional.AlgebraicDataType] = Seq.empty, + functions: Seq[any.Method] = Seq.empty, + tests: Seq[any.TestSuite] = Seq.empty, + ): anyOverrides.CompilationUnit = scalaBaseFactory.scalaCompilationUnit( + name = name, + imports = imports, + methodTypeLookupMap = Map.empty, + constructorTypeLookupMap = Map.empty, + classTypeLookupMap = Map.empty, + adtTypeLookupMap = adtTypeLookupMap, + functionTypeLookupMap = functionTypeLookupMap, + classes = Seq.empty, + adts = adts, + functions = functions, + tests = tests) + + } + + } + + object ooOverrides { + trait FinalTypes extends oo.FinalTypes with generics.ooOverrides.FinalTypes { + type Class <: ooOverrides.Class + type Constructor <: ooOverrides.Constructor + type Field <: ooOverrides.Field + type MemberAccessExpression <: ooOverrides.MemberAccessExpression + type SelfReferenceExpression <: ooOverrides.SelfReferenceExpression + type ObjectInstantiationExpression <: ooOverrides.ObjectInstantiationExpression + type CastExpression <: ooOverrides.CastExpression + type InstanceOfExpression <: ooOverrides.InstanceOfExpression + type SuperReferenceExpression <: ooOverrides.SuperReferenceExpression + type ClassReferenceType <: ooOverrides.ClassReferenceType + } + + trait Class extends generics.ooOverrides.Class with Util { + import factory.* + import ooFactory.* + import polymorphismFactory.* + + + def findClass(qualifiedName: any.Name*): any.Type = { + classReferenceType(qualifiedName *) + } + + def classBodyDefinitionToScala: String = { + val importDecls = imports.map(_.toScala).mkString("\n ") + val fieldDecls = fields.map(_.toScala).mkString("\n ") + val methodDecls = methods.map(_.toScala).mkString("\n ") + val secondaryConstructorDecls = if (constructors.isEmpty) "" else constructors.tail.map(_.toScala).mkString("\n ") + val initBlock = constructors.headOption.map(ctor => + ctor.primaryConstructorBody(this) + ).getOrElse(fieldDecls) + s""" + |{ + | $importDecls + | $initBlock + | $secondaryConstructorDecls + | $methodDecls + |}""".stripMargin + } + + def toScala: String = { + val kind = if (isInterface) "trait" else if (isStatic) "object" else "class" + val abstractMod = if (isAbstract && !isInterface) "abstract" else "" + val typeParams = { + val ps = typeParameters.map(_.toScala) + if (!isStatic && ps.nonEmpty) ps.mkString("[", ",", "]") else "" + } + val extendsClause = constructors.headOption.map(ctor => + ctor.parentInitializers(this) + ).getOrElse { + val supers = (parents ++ implemented).distinct + if (supers.nonEmpty) supers.map(_.toScala).mkString("extends ", " with ", "") else "" + } + val primaryConstructorParams = constructors.headOption.map(ctor => + ctor.primaryConstructorParams + ).getOrElse("") + + + s""" + |$abstractMod $kind ${name.toScala}$typeParams$primaryConstructorParams $extendsClause $classBodyDefinitionToScala""".stripMargin + } + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.Class = { + copyAsGenericClass( + imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + typeParameters = typeParameters.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + parents = parents.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + implemented = implemented.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + fields = fields.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + methods = methods.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + constructors = constructors.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + methodTypeLookupMap = tpeRep => methodTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + } + + trait Constructor extends oo.Constructor with anyOverrides.Method { + import factory.* + import ooFactory.* + + override def typeParameters: Seq[polymorphism.TypeParameter] = Seq.empty + override def name: any.Name = nameProvider.mangle(constructedType.map(_.toScala).getOrElse("")) + override def returnType: Option[any.Type] = constructedType + + def importDecls: String = imports.map(_.toScala).mkString("\n ") + + override def toScala: String = { + val params = parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString(",") + val superInitDecls = if (superInitialization.isDefined) { + s"// Potential Generator Defect: Scala cannot declare supers in secondary constructor" + } else "" + val fieldInitDecls = fieldInitializers.map(fi => { + s"${fi._2.toScala}" + }).mkString(", ") + val bodyDecls = + s""" + | ${statements.map(_.toScala).mkString("\n ")} + """.stripMargin + + s"""def this($params) = { + | this($fieldInitDecls) + | $importDecls + | $bodyDecls + |}""".stripMargin + } + + def primaryConstructorParams: String = { + parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString("(", ",", ")") + } + + def parentInitializers(ofClass: oo.Class): String = { + val supers = (ofClass.parents ++ ofClass.implemented).distinct + superInitialization match { + case Some((parent, parentArgs)) => + val rest = supers.filter(sp => sp != parent).map(_.toScala) + val withRest = if (rest.isEmpty) "" else rest.mkString("with ", " with ", "") + s"extends ${parent.toScala}(${parentArgs.map(_.toScala).mkString(", ")}) $withRest" + case None => + if (supers.nonEmpty) supers.map(_.toScala).mkString("extends ", " with ", "") else "" + } + } + + def primaryConstructorBody(ofClass: oo.Class): String = { + val (fieldDeclarations, remainingPrimaryInits) = { + ofClass.fields.foldLeft[(Seq[String], Seq[(any.Name, any.Expression)])]((Seq.empty, fieldInitializers)) { + case ((decls, remainingInitializers), declaredField) => { + if (declaredField.init.isDefined) { + (decls :+ declaredField.toScala, remainingInitializers) + } else { + def extractFirstDeclaration(decls: Seq[(any.Name, any.Expression)]): (Seq[(any.Name, any.Expression)], Option[any.Expression]) = + decls match { + case (name, init) +: rest if name == declaredField.name => + (rest, Some(init)) + case hd +: rest => + val (remaining, init) = extractFirstDeclaration(rest) + (hd +: remaining, init) + case _ => (Seq.empty, None) + } + + val (remaining, init) = extractFirstDeclaration(remainingInitializers) + (decls :+ declaredField.copy(init = init).toScala, remaining) + } + } + } + } + val overrideInits = remainingPrimaryInits.map(fi => { + s"this.${fi._1.toScala} = ${fi._2.toScala}" + }).mkString(" \n") + val bodyDecls = + s""" + | ${statements.map(_.toScala).mkString("\n ")} + """.stripMargin + s""" + | $importDecls + | ${fieldDeclarations.mkString("\n ")} + | $overrideInits + | $bodyDecls + | """.stripMargin + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.Constructor = { + copyAsConstructor( + constructedType = constructedType.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + statements = statements.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + parameters = parameters.map { case (name, tpe) => (name, tpe.prefixRootPackage(rootPackageName, excludedTypeNames)) }, + typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + superInitialization = superInitialization.map { case (tpe, exps) => + (tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + exps.map(_.prefixRootPackage(rootPackageName, excludedTypeNames))) + }, + fieldInitializers = fieldInitializers.map { case (name, exp) => (name, exp.prefixRootPackage(rootPackageName, excludedTypeNames)) } + ) + } + } + + trait Field extends oo.Field { + import factory.* + + def toScala: String = { + val initExp = init.map(exp => s" = ${exp.toScala}").getOrElse(s" = null.asInstanceOf[${tpe.toScala}]") + s"var ${name.toScala}: ${tpe.toScala}$initExp" + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.Field = { + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + init = init.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + ) + } + } + + trait MemberAccessExpression extends anyOverrides.Expression with oo.MemberAccessExpression { + import factory.* + + def toScala: String = s"${owner.toScala}.${field.toScala}" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.MemberAccessExpression = + copy(owner = owner.prefixRootPackage(rootPackageName, excludedTypeNames)) + } + + trait SelfReferenceExpression extends anyOverrides.Expression with oo.SelfReferenceExpression { + def toScala: String = s"this" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.SelfReferenceExpression = + this + } + + trait ObjectInstantiationExpression extends anyOverrides.Expression with oo.ObjectInstantiationExpression { + import factory.* + import ooFactory.* + + def toScala: String = { + val bodyScala = body.map(_.classBodyDefinitionToScala).getOrElse("") + s"""new ${tpe.toScala}(${constructorArguments.map(_.toScala).mkString(",")})$bodyScala""" + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.ObjectInstantiationExpression = + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + constructorArguments = constructorArguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + body = body.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + + trait CastExpression extends anyOverrides.Expression with oo.CastExpression { + import factory.* + + def toScala: String = s"${this.expression.toScala}.asInstanceOf[${tpe.toScala}]" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.CastExpression = + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait InstanceOfExpression extends anyOverrides.Expression with oo.InstanceOfExpression { + import factory.* + + def toScala: String = { + s"${this.expression.toScala}.isInstanceOf[${this.tpe.toScala}]" + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.InstanceOfExpression = + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait SuperReferenceExpression extends anyOverrides.Expression with oo.SuperReferenceExpression { + import factory.* + + def toScala: String = { + s"super[${parentType.toScala}]" + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.SuperReferenceExpression = + copy( + parentType = parentType.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait ClassReferenceType extends oo.ClassReferenceType with anyOverrides.Type { + import factory.* + + def toScala: String = qualifiedClassName.map(_.toScala).mkString(".") + + def toImport: Seq[any.Import] = Seq.empty + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): oo.ClassReferenceType = { + if (excludedTypeNames.contains(qualifiedClassName)) { + this + } else { + copy( + qualifiedClassName = rootPackageName ++ qualifiedClassName + ) + } + } + } + + trait Factory extends generics.ooOverrides.Factory { + override def ooProject( + compilationUnits: Set[any.CompilationUnit], + customFiles: Seq[FileWithPath], + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = Map.empty, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = Map.empty, + ): anyOverrides.Project = scalaBaseFactory.scalaProject( + compilationUnits = compilationUnits, + customFiles = customFiles, + adtTypeLookupMap = Map.empty, + functionTypeLookupMap = Map.empty, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + classTypeLookupMap = classTypeLookupMap, + ) + + override def ooCompilationUnit( + name: Seq[any.Name], + imports: Seq[any.Import], + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = Map.empty, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = Map.empty, + classes: Seq[oo.Class] = Seq.empty, + tests: Seq[any.TestSuite] = Seq.empty, + ): anyOverrides.CompilationUnit = scalaBaseFactory.scalaCompilationUnit( + name = name, + imports = imports, + methodTypeLookupMap = methodTypeLookupMap, + constructorTypeLookupMap = constructorTypeLookupMap, + classTypeLookupMap = classTypeLookupMap, + adtTypeLookupMap = Map.empty, + functionTypeLookupMap = Map.empty, + classes = classes, + adts = Seq.empty, + functions = Seq.empty, + tests = tests, + ) + + } + } + + object functionalControlOverrides { + trait FinalTypes extends funcontrol.FinalTypes { + type Lambda <: functionalControlOverrides.Lambda + type DeclareFunVariable <: functionalControlOverrides.DeclareFunVariable + type FunIfThenElse <: functionalControlOverrides.IfThenElse + type PatternMatch <: functionalControlOverrides.PatternMatch + type PatternContext <: functionalControlOverrides.PatternContext + type PatternVariable <: functionalControlOverrides.PatternVariable + type ConstructorPattern <: functionalControlOverrides.ConstructorPattern + } + + trait Lambda extends funcontrol.Lambda with anyOverrides.Expression { + import factory.* + + def toScala: String = { + val vars = this.variables.map { case (v, tpe) => s"${v.toScala}: ${tpe.toScala}" }.mkString("(", ", ", ")") + val body = this.body.toScala + s"$vars => {\n $body \n}" + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Expression = + copy( + variables = this.variables.map { case (v, tpe) => (v, tpe.prefixRootPackage(rootPackageName, excludedTypeNames)) }, + body = this.body.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait DeclareFunVariable extends funcontrol.DeclareFunVariable with anyOverrides.Expression { + import factory.* + import functionalControlFactory.* + + def toScala: String = { + val decl = if (this.isRecursive) "def" else "val" + val body = this.inExp.toScala + s""" + |{ $decl ${this.name.toScala}: ${this.tpe.toScala} = ${this.initializer.toScala} + | $body } + |""".stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): DeclareFunVariable = { + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + initializer = initializer.prefixRootPackage(rootPackageName, excludedTypeNames), + inExp = inExp.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + } + + trait IfThenElse extends funcontrol.IfThenElse with anyOverrides.Expression { + import factory.* + + def toScala: String = { + val elseIfs = elseIfBranches.map { case (condition, body) => + s""" + | else if (${condition.toScala}) { + | ${body.toScala} + |}""".stripMargin + } + + s""" + |if (${condition.toScala}) { + | ${this.ifBranch.toScala} + |}${elseIfs.mkString("")} else { + | ${elseBranch.toScala} + |} + """.stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): funcontrol.IfThenElse = + copy( + condition = condition.prefixRootPackage(rootPackageName, excludedTypeNames), + ifBranch = ifBranch.prefixRootPackage(rootPackageName, excludedTypeNames), + elseIfBranches = elseIfBranches.map { case (cond, branch) => + (cond.prefixRootPackage(rootPackageName, excludedTypeNames), + branch.prefixRootPackage(rootPackageName, excludedTypeNames)) + }, + elseBranch = elseBranch.prefixRootPackage(rootPackageName, excludedTypeNames), + ) + } + + trait PatternMatch extends funcontrol.PatternMatch with anyOverrides.Expression { + import factory.* + + override def toScala: String = { + val cases = this.cases.map { case (pat, body) => s"case ${pat.toScala} => { ${body.toScala} }" }.mkString("\n ") + s""" + |${onValue.toScala} match { + | $cases + |}""".stripMargin + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): funcontrol.PatternMatch = { + copy( + onValue = this.onValue.prefixRootPackage(rootPackageName, excludedTypeNames), + cases = this.cases.map { case (pat, body) => (pat.prefixRootPackage(rootPackageName, excludedTypeNames), body.prefixRootPackage(rootPackageName, excludedTypeNames)) } + ) + } + } + + trait PatternContext extends funcontrol.PatternContext with Util { + } + + trait PatternVariable extends funcontrol.PatternVariable with anyOverrides.Expression { + import factory.* + + override def toScala: String = this.name.toScala + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): funcontrol.PatternVariable = this + } + + trait ConstructorPattern extends funcontrol.ConstructorPattern with anyOverrides.Expression { + import factory.* + + override def toScala: String = { + s"""${tpe.toScala}.${constructor.toScala}(${arguments.map(_.toScala).mkString(", ")})""" + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): funcontrol.ConstructorPattern = { + copy( + tpe = this.tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + arguments = this.arguments.map(arg => arg.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + } + + trait Factory extends funcontrol.Factory {} + } + + object polymorphismOverrides { + trait FinalTypes extends generics.polymorphismOverrides.FinalTypes { + type TypeReferenceExpression <: polymorphismOverrides.TypeReferenceExpression + type TypeParameter <: polymorphismOverrides.TypeParameter + type TypeArgument <: polymorphismOverrides.TypeArgument + type TypeApplication <: polymorphismOverrides.TypeApplication + } + + trait TypeReferenceExpression extends polymorphism.TypeReferenceExpression with anyOverrides.Expression { + import factory.* + + def toScala: String = tpe.toScala + + override def isTypeReferenceExpression: Boolean = true + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): polymorphism.TypeReferenceExpression = { + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + } + + trait TypeParameter extends generics.polymorphismOverrides.TypeParameter { + import factory.* + + def toScala: String = { + val lbs = + if (lowerBounds.nonEmpty) " <: " + lowerBounds.map(_.toScala).mkString(" with ") else "" + val ubs = + if (upperBounds.nonEmpty) " >: " + upperBounds.map(_.toScala).mkString(" with ") else "" + s"""${name.toScala}$lbs$ubs""" + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): polymorphism.TypeParameter = { + copyAsTypeParameterWithBounds( + upperBounds = upperBounds.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + lowerBounds = lowerBounds.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + ) + } + } + + trait TypeArgument extends polymorphism.TypeArgument with anyOverrides.Type { + import factory.* + def toScala: String = name.toScala + + def toImport: Seq[any.Import] = Seq.empty + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): polymorphism.TypeArgument = { + this + } + } + + trait TypeApplication extends polymorphism.TypeApplication with anyOverrides.Type { + import factory.* + + def toScala: String = { + s"${function.toScala}[${arguments.map(_.toScala).mkString(", ")}]" + } + + def toImport: Seq[any.Import] = function.toImport ++ arguments.flatMap(_.toImport) + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): polymorphism.TypeApplication = { + copy( + function = function.prefixRootPackage(rootPackageName, excludedTypeNames), + arguments = arguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + } + + trait Factory extends generics.polymorphismOverrides.Factory {} + } + + object imperativeOverrides { + trait FinalTypes extends imperative.FinalTypes { + type DeclareVariable <: imperativeOverrides.DeclareVariable + type AssignVariable <: imperativeOverrides.AssignVariable + type IfThenElse <: imperativeOverrides.IfThenElse + type While <: imperativeOverrides.While + type VariableReferenceExpression <: imperativeOverrides.VariableReferenceExpression + } + + trait DeclareVariable extends imperative.DeclareVariable with anyOverrides.Statement { + import factory.* + def toScala: String = { + val init = this.initializer.map(ie => s" = ${ie.toScala}").getOrElse("") + s""" + |var ${this.name.toScala}: ${this.tpe.toScala}$init + |""".stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): imperative.DeclareVariable = { + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + initializer = initializer.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + } + + trait AssignVariable extends imperative.AssignVariable with anyOverrides.Statement { + import factory.* + + def toScala: String = { + s""" + |${this.variable.toScala} = ${this.assignmentExpression.toScala} + |""".stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): imperative.AssignVariable = + copy(assignmentExpression = assignmentExpression.prefixRootPackage(rootPackageName, excludedTypeNames)) + } + + trait IfThenElse extends imperative.IfThenElse with anyOverrides.Statement { + import factory.* + + def toScala: String = { + val elseIfs = elseIfBranches.map { case (condition, body) => + s""" + |else if (${condition.toScala}) { + | ${body.map(_.toScala).mkString("\n ")} + |}""".stripMargin + } + + s""" + |if (${condition.toScala}) { + | ${this.ifBranch.map(_.toScala).mkString("\n ")} + |}${elseIfs.mkString("")} else { + | ${elseBranch.map(_.toScala).mkString("\n ")} + |} + """.stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): imperative.IfThenElse = + copy( + condition = condition.prefixRootPackage(rootPackageName, excludedTypeNames), + ifBranch = ifBranch.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + elseIfBranches = elseIfBranches.map { case (cond, branch) => + (cond.prefixRootPackage(rootPackageName, excludedTypeNames), + branch.map(_.prefixRootPackage(rootPackageName, excludedTypeNames))) + }, + elseBranch = elseBranch.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), + ) + } + + trait While extends imperative.While with anyOverrides.Statement { + import factory.* + + def toScala: String = { + s""" + |while (${condition.toScala}) { + | ${body.map(_.toScala).mkString("\n ")} + |}""".stripMargin + } + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): imperative.While = + copy( + condition = condition.prefixRootPackage(rootPackageName, excludedTypeNames), + body = body.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + + trait VariableReferenceExpression extends anyOverrides.Expression with imperative.VariableReferenceExpression { + import factory.* + + def toScala: String = s"${name.toScala}" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): imperative.VariableReferenceExpression = + this + } + + trait LiftExpression extends imperative.LiftExpression with anyOverrides.Statement { + import factory.* + def toScala: String = s"${this.expression.toScala};" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): imperative.LiftExpression = + copy( + expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait Factory extends imperative.Factory {} + } + + trait FinalTypes { + type ReifiedScalaValue[T] <: scalaBase.ReifiedScalaValue[T] + type BlockExpression <: scalaBase.BlockExpression + type MethodReferenceExpression <: scalaBase.MethodReferenceExpression + } + + trait Util { + import factory.* + + def nameProvider: NameProvider[any.Name] = nameProviderFactory.scalaNameProvider + def reify[T](tpe: OfHostType[T], value: T): any.Expression = scalaBaseFactory.reifiedScalaValue(tpe, value) + + def findType(name: Seq[any.Name]): any.Type = functionalFactory.adtReferenceType(name *) + + def resolveImport(tpe: any.Type): Seq[any.Import] = tpe.toImport + def resolveImport(expr: any.Expression): Seq[any.Import] = expr.toImport + def getFreshName(basedOn: any.Name): any.Name = { + val id = UUID.randomUUID().toString.replace("-", "") + nameProvider.mangle(s"${basedOn.component}_$id") + } + } + + trait ReifiedScalaValue[T] extends anyOverrides.Expression { + import scalaBaseFactory.* + + def getSelfAsReifiedScalaValue: scalaBaseFinalTypes.ReifiedScalaValue[T] + val ofHostType: OfHostType[T] + val value: T + + def toScala: String = { + reificationExtensions.collectFirst(Function.unlift(ext => ext(ofHostType)(value))).getOrElse( + ofHostType match { + case t: TypeRep.String.type => s""""$value"""" + case t: TypeRep.Sequence[_] => + value.asInstanceOf[Seq[t.elemTpe.HostType]].map(v => reifiedScalaValue(t.elemTpe, v).toScala).mkString("Seq(", ", ", ")") + case t: TypeRep.Array[_] => + value.asInstanceOf[Array[t.elemTpe.HostType]].map(v => reifiedScalaValue(t.elemTpe, v).toScala).mkString("Array(", ", ", ")") + case _ => + value.toString + } + ) + } + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): ReifiedScalaValue[T] = + this + } + + trait MethodReferenceExpression extends anyOverrides.Expression { + import factory.* + + def getSelfAsMethodReferenceExpression: scalaBaseFinalTypes.MethodReferenceExpression + + def qualifiedMethodName: Seq[any.Name] + + def toScala: String = qualifiedMethodName.map(_.toScala).mkString(".") + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): MethodReferenceExpression = { + if (excludedTypeNames.contains(qualifiedMethodName)) { + this + } else { + copy( + qualifiedMethodName = rootPackageName ++ qualifiedMethodName + ) + } + } + + def copy(qualifiedMethodName: Seq[any.Name] = this.qualifiedMethodName): MethodReferenceExpression = + scalaBaseFactory.methodReferenceExpression(qualifiedMethodName) + } + + trait BlockExpression extends anyOverrides.Expression { + import factory.* + + def getSelfBlockExpression: scalaBaseFinalTypes.BlockExpression + + def statements: Seq[any.Statement] = Seq.empty + + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): BlockExpression = { + copy( + statements = statements.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) + ) + } + + def toScala: String = { + statements.map(_.toScala).mkString("{\n", "\n ", "}") + } + + def copy(statements: Seq[any.Statement] = this.statements): BlockExpression = + scalaBaseFactory.blockExpression(statements) + } + + trait Factory { + def name(name: String, mangled: String): any.Name + + def scalaProject( + compilationUnits: Set[any.CompilationUnit], + customFiles: Seq[FileWithPath] = Seq.empty, + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = Map.empty, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = Map.empty, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + ): anyOverrides.Project + + def scalaCompilationUnit( + name: Seq[any.Name], + imports: Seq[any.Import], + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type] = Map.empty, + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type] = Map.empty, + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type] = Map.empty, + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] = Map.empty, + classes: Seq[oo.Class] = Seq.empty, + adts: Seq[functional.AlgebraicDataType] = Seq.empty, + functions: Seq[any.Method] = Seq.empty, + tests: Seq[any.TestSuite] = Seq.empty, + ): anyOverrides.CompilationUnit + + def importStatement(components: Seq[any.Name]): anyOverrides.Import + + def reifiedScalaValue[T](ofHostType: OfHostType[T], value: T): scalaBase.ReifiedScalaValue[T] + def methodReferenceExpression(qualifiedMethodName: Seq[any.Name]): scalaBase.MethodReferenceExpression + def blockExpression(statements: Seq[any.Statement]): scalaBase.BlockExpression + + implicit def convert[T](other: scalaBase.ReifiedScalaValue[T]): scalaBaseFinalTypes.ReifiedScalaValue[T] = other.getSelfAsReifiedScalaValue + implicit def convert(other: scalaBase.MethodReferenceExpression): scalaBaseFinalTypes.MethodReferenceExpression = other.getSelfAsMethodReferenceExpression + implicit def convert(other: scalaBase.BlockExpression): scalaBaseFinalTypes.BlockExpression = other.getSelfBlockExpression + } + } + + override val finalTypes: scalaBase.anyOverrides.FinalTypes + override val ooFinalTypes: scalaBase.ooOverrides.FinalTypes + override val functionalFinalTypes: scalaBase.functionalOverrides.FinalTypes + override val functionalControlFinalTypes: scalaBase.functionalControlOverrides.FinalTypes + override val polymorphismFinalTypes: scalaBase.polymorphismOverrides.FinalTypes + override val imperativeFinalTypes: scalaBase.imperativeOverrides.FinalTypes + val scalaBaseFinalTypes: scalaBase.FinalTypes + + override val factory: scalaBase.anyOverrides.Factory + override val ooFactory: scalaBase.ooOverrides.Factory + override val functionalFactory: scalaBase.functionalOverrides.Factory + override val functionalControlFactory: scalaBase.functionalControlOverrides.Factory + override val polymorphismFactory: scalaBase.polymorphismOverrides.Factory + override val imperativeFactory: scalaBase.imperativeOverrides.Factory + val reificationExtensions: List[(tpe: TypeRep) => (value: tpe.HostType) => Option[String]] + val scalaBaseFactory: scalaBase.Factory +} + +trait FinalBaseAST extends BaseAST { + + object finalBaseAST { + object anyOverrides { + trait FinalExpression extends scalaBase.anyOverrides.Expression { + override def getSelfExpression: finalTypes.Expression = this + } + + trait FinalStatement extends scalaBase.anyOverrides.Statement { + def getSelfStatement: finalTypes.Statement = this + } + } + } + + object finalBaseFinalTypes { + trait FinalTypes extends scalaBase.anyOverrides.FinalTypes { + type Project = scalaBase.anyOverrides.Project + type CompilationUnit = scalaBase.anyOverrides.CompilationUnit + type Method = scalaBase.anyOverrides.Method + type Expression = finalBaseAST.anyOverrides.FinalExpression + type TestSuite = scalaBase.anyOverrides.TestSuite + type Import = scalaBase.anyOverrides.Import + type Statement = scalaBase.anyOverrides.Statement + type Type = scalaBase.anyOverrides.Type + type Name = scalaBase.anyOverrides.Name + type ApplyExpression = scalaBase.anyOverrides.ApplyExpression + type ArgumentExpression = scalaBase.anyOverrides.ArgumentExpression + } + + trait OOFinalTypes extends scalaBase.ooOverrides.FinalTypes { + import scalaBase.ooOverrides + type Class = ooOverrides.Class + type Constructor = ooOverrides.Constructor + type Field = ooOverrides.Field + type MemberAccessExpression = ooOverrides.MemberAccessExpression + type SelfReferenceExpression = ooOverrides.SelfReferenceExpression + type ObjectInstantiationExpression = ooOverrides.ObjectInstantiationExpression + type CastExpression = ooOverrides.CastExpression + type InstanceOfExpression = ooOverrides.InstanceOfExpression + type SuperReferenceExpression = ooOverrides.SuperReferenceExpression + type ClassReferenceType = ooOverrides.ClassReferenceType + } + + trait FunctionalFinalTypes extends scalaBase.functionalOverrides.FinalTypes { + import scalaBase.functionalOverrides + + type AlgebraicDataType = functionalOverrides.AlgebraicDataType + type TypeConstructor = functionalOverrides.TypeConstructor + type TypeInstantiationExpression = functionalOverrides.TypeInstantiationExpression + type ADTReferenceType = functionalOverrides.ADTReferenceType + } + + trait FunctionalControlFinalTypes extends scalaBase.functionalControlOverrides.FinalTypes { + import scalaBase.functionalControlOverrides + + type Lambda = functionalControlOverrides.Lambda + type DeclareFunVariable = functionalControlOverrides.DeclareFunVariable + type FunIfThenElse = functionalControlOverrides.IfThenElse + type PatternMatch = functionalControlOverrides.PatternMatch + type PatternContext = functionalControlOverrides.PatternContext + type PatternVariable = functionalControlOverrides.PatternVariable + type ConstructorPattern = functionalControlOverrides.ConstructorPattern + } + + trait PolymorphismFinalTypes extends scalaBase.polymorphismOverrides.FinalTypes { + import scalaBase.polymorphismOverrides + + type TypeReferenceExpression = polymorphismOverrides.TypeReferenceExpression + type TypeParameter = polymorphismOverrides.TypeParameter + type TypeArgument = polymorphismOverrides.TypeArgument + type TypeApplication = polymorphismOverrides.TypeApplication + } + + trait ImperativeFinalTypes extends scalaBase.imperativeOverrides.FinalTypes { + import scalaBase.imperativeOverrides + + type DeclareVariable = imperativeOverrides.DeclareVariable + type AssignVariable = imperativeOverrides.AssignVariable + type IfThenElse = imperativeOverrides.IfThenElse + type While = imperativeOverrides.While + type VariableReferenceExpression = imperativeOverrides.VariableReferenceExpression + } + + trait ScalaBaseFinalTypes extends scalaBase.FinalTypes { + type ReifiedScalaValue = scalaBase.ReifiedScalaValue + type BlockExpression = scalaBase.BlockExpression + type MethodReferenceExpression = scalaBase.MethodReferenceExpression + } + } + + override val finalTypes: finalBaseFinalTypes.FinalTypes = new finalBaseFinalTypes.FinalTypes {} + override val ooFinalTypes: finalBaseFinalTypes.OOFinalTypes = new finalBaseFinalTypes.OOFinalTypes {} + override val functionalFinalTypes: finalBaseFinalTypes.FunctionalFinalTypes = new finalBaseFinalTypes.FunctionalFinalTypes {} + override val functionalControlFinalTypes: finalBaseFinalTypes.FunctionalControlFinalTypes = new finalBaseFinalTypes.FunctionalControlFinalTypes {} + override val polymorphismFinalTypes: finalBaseFinalTypes.PolymorphismFinalTypes = new finalBaseFinalTypes.PolymorphismFinalTypes {} + override val imperativeFinalTypes: finalBaseFinalTypes.ImperativeFinalTypes = new finalBaseFinalTypes.ImperativeFinalTypes {} + override val scalaBaseFinalTypes: finalBaseFinalTypes.ScalaBaseFinalTypes = new finalBaseFinalTypes.ScalaBaseFinalTypes {} + + object FinalBaseFactoryTypes { + trait Factory extends scalaBase.anyOverrides.Factory { + + def returnExpression(expression: any.Expression): any.Return = { + case class Return(override val expression: any.Expression) extends scalaBase.anyOverrides.Return with finalBaseAST.anyOverrides.FinalStatement { + } + Return(expression) + } + def applyExpression(function: any.Expression, arguments: Seq[any.Expression]): any.ApplyExpression = { + case class ApplyExpression( + override val function: any.Expression, + override val arguments: Seq[any.Expression]) + extends scalaBase.anyOverrides.ApplyExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfApplyExpression: finalTypes.ApplyExpression = this + } + ApplyExpression(function, arguments) + } + def argumentExpression(parameterName: any.Name): any.ArgumentExpression = { + case class ArgumentExpression(override val parameterName: any.Name) extends scalaBase.anyOverrides.ArgumentExpression with finalBaseAST.anyOverrides.FinalExpression { + def getSelfArgumentExpression: finalTypes.ArgumentExpression = this + } + ArgumentExpression(parameterName) + } + } + + trait OOFactory extends scalaBase.ooOverrides.Factory { + def classBasedTestSuite(underlyingClass: oo.Class, testMarkers: Seq[Boolean]): oo.anyOverrides.TestSuite = { + class ClassBasedTestSuite( + override val underlyingClass: oo.Class, + override val testMarkers: Seq[Boolean] + ) extends scalaBase.anyOverrides.TestSuite { + override def getSelfTestSuite: finalTypes.TestSuite = this + } + ClassBasedTestSuite(underlyingClass, testMarkers) + } + + def constructor(constructedType: Option[any.Type], imports: Set[any.Import], statements: Seq[any.Statement], parameters: Seq[(any.Name, any.Type)], typeLookupMap: TypeRep => Generator[any.Method, any.Type], constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], superInitialization: Option[(any.Type, Seq[any.Expression])], fieldInitializers: Seq[(any.Name, any.Expression)]): oo.Constructor = { + class Constructor( + override val constructedType: Option[any.Type], + override val imports: Set[any.Import], + override val statements: Seq[any.Statement], + override val parameters: Seq[(any.Name, any.Type)], + override val typeLookupMap: TypeRep => Generator[any.Method, any.Type], + override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], + override val superInitialization: Option[(any.Type, Seq[any.Expression])], + override val fieldInitializers: Seq[(any.Name, any.Expression)]) + extends scalaBase.ooOverrides.Constructor { + override def getSelfMethod: scalaBase.anyOverrides.Method = this + override def getSelfConstructor: scalaBase.ooOverrides.Constructor = this + } + Constructor(constructedType, imports, statements, parameters, typeLookupMap, constructorTypeLookupMap, superInitialization, fieldInitializers) + } + + def field(name: any.Name, tpe: any.Type, init: Option[any.Expression]): oo.Field = { + case class Field( + override val name: any.Name, + override val tpe: any.Type, + override val init: Option[any.Expression]) + extends scalaBase.ooOverrides.Field { + override def getSelfField: scalaBase.ooOverrides.Field = this + } + Field(name, tpe, init) + } + def memberAccessExpression(owner: any.Expression, field: any.Name): oo.MemberAccessExpression = { + case class MemberAccessExpression( + override val owner: any.Expression, + override val field: any.Name) + extends scalaBase.ooOverrides.MemberAccessExpression + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfMemberAccessExpression: scalaBase.ooOverrides.MemberAccessExpression = this + } + MemberAccessExpression(owner, field) + } + def objectInstantiationExpression(tpe: any.Type, constructorArguments: Seq[any.Expression], body: Option[oo.Class]): oo.ObjectInstantiationExpression = { + case class ObjectInstantiationExpression( + override val tpe: any.Type, + override val constructorArguments: Seq[any.Expression], + override val body: Option[oo.Class]) + extends scalaBase.ooOverrides.ObjectInstantiationExpression + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfObjectInstantiationExpression: scalaBase.ooOverrides.ObjectInstantiationExpression = this + } + ObjectInstantiationExpression(tpe, constructorArguments, body) + } + def castExpression(tpe: any.Type, expression: any.Expression): oo.CastExpression = { + case class CastExpression( + override val tpe: any.Type, + override val expression: any.Expression) + extends scalaBase.ooOverrides.CastExpression + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfCastExpression: scalaBase.ooOverrides.CastExpression = this + } + CastExpression(tpe, expression) + } + def instanceOfExpression(tpe: any.Type, expression: any.Expression): oo.InstanceOfExpression = { + case class InstanceOfExpression( + override val tpe: any.Type, + override val expression: any.Expression) + extends scalaBase.ooOverrides.InstanceOfExpression + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfInstanceOfExpression: scalaBase.ooOverrides.InstanceOfExpression = this + } + InstanceOfExpression(tpe, expression) + } + def superReferenceExpression(parentType: any.Type): oo.SuperReferenceExpression = { + case class SuperReferenceExpression( + override val parentType: any.Type) + extends scalaBase.ooOverrides.SuperReferenceExpression + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfSuperReferenceExpression: scalaBase.ooOverrides.SuperReferenceExpression = this + } + SuperReferenceExpression(parentType) + } + def selfReferenceExpression: oo.SelfReferenceExpression = { + case class SelfReferenceExpression() + extends scalaBase.ooOverrides.SelfReferenceExpression + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfSelfReferenceExpression: scalaBase.ooOverrides.SelfReferenceExpression = this + } + SelfReferenceExpression() + } + def classReferenceType(qualifiedClassName: any.Name*): oo.ClassReferenceType = { + case class ClassReferenceType( + override val qualifiedClassName: any.Name*) + extends scalaBase.ooOverrides.ClassReferenceType { + override def getSelfType: scalaBase.anyOverrides.Type = this + override def getSelfClassReferenceType: scalaBase.ooOverrides.ClassReferenceType = this + } + ClassReferenceType(qualifiedClassName*) + } + } + + trait FunctionalFactory extends scalaBase.functionalOverrides.Factory { + def adt(name: any.Name, + imports: Seq[any.Import], + typeConstructors: Seq[functional.TypeConstructor], + typeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type]): functional.AlgebraicDataType = { + case class ADT(override val name: any.Name, + override val imports: Seq[any.Import], + override val typeConstructors: Seq[functional.TypeConstructor], + override val typeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type]) + extends scalaBase.functionalOverrides.AlgebraicDataType { + def getSelfAlgebraicDataType: functionalFinalTypes.AlgebraicDataType = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + ADT(name, imports, typeConstructors, typeLookupMap) + } + def typeConstructor(name: any.Name, parameters: Seq[(any.Name, any.Type)]): functional.TypeConstructor = { + case class TypeConstructor(override val name: any.Name, + override val parameters: Seq[(any.Name, any.Type)] + ) extends scalaBase.functionalOverrides.TypeConstructor { + def getSelfTypeConstructor: functionalFinalTypes.TypeConstructor = this + } + TypeConstructor(name, parameters) + } + def typeInstantiationExpression(tpe: any.Type, constructorName: Seq[any.Name], constructorArguments: Seq[any.Expression]): functional.TypeInstantiationExpression = { + case class TypeInstantiationExpression( + override val tpe: any.Type, + override val constructorName: Seq[any.Name], + override val constructorArguments: Seq[any.Expression]) + extends scalaBase.functionalOverrides.TypeInstantiationExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfTypeInstantiationExpression: functionalFinalTypes.TypeInstantiationExpression = this + } + TypeInstantiationExpression(tpe, constructorName, constructorArguments) + } + def adtReferenceType(qualifiedTypeName: any.Name*): functional.ADTReferenceType = { + case class AdtReferenceType(override val qualifiedTypeName: any.Name*) + extends scalaBase.functionalOverrides.ADTReferenceType { + def getSelfADTReferenceType: functionalFinalTypes.ADTReferenceType = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + AdtReferenceType(qualifiedTypeName*) + } + } + + trait FunctionalControlFactory extends scalaBase.functionalControlOverrides.Factory { + def lambda(variables: Seq[(any.Name, any.Type)], body: any.Expression): funcontrol.Lambda = { + case class Lambda( + override val variables: Seq[(any.Name, any.Type)], + override val body: any.Expression + ) extends scalaBase.functionalControlOverrides.Lambda + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfLambda: functionalControlFinalTypes.Lambda = this + } + Lambda(variables, body) + } + def declareFunVariable(name: any.Name, tpe: any.Type, isRecursive: Boolean, initializer: any.Expression, inExp: any.Expression): funcontrol.DeclareFunVariable = { + case class DeclareFunVariable( + override val name: any.Name, + override val tpe: any.Type, + override val isRecursive: Boolean, + override val initializer: any.Expression, + override val inExp: any.Expression + ) extends scalaBase.functionalControlOverrides.DeclareFunVariable + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfDeclareFunVariable: functionalControlFinalTypes.DeclareFunVariable = this + } + DeclareFunVariable(name, tpe, isRecursive, initializer, inExp) + } + def funIfThenElse(condition: any.Expression, ifBranch: any.Expression, elseIfBranches: Seq[(any.Expression, any.Expression)], elseBranch: any.Expression): funcontrol.IfThenElse = { + case class FunIfThenElse( + override val condition: any.Expression, + override val ifBranch: any.Expression, + override val elseIfBranches: Seq[(any.Expression, any.Expression)], + override val elseBranch: any.Expression + ) extends scalaBase.functionalControlOverrides.IfThenElse + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfFunIfThenElse: functionalControlFinalTypes.FunIfThenElse = this + } + FunIfThenElse(condition, ifBranch, elseIfBranches, elseBranch) + } + def patternContext(variables: Seq[any.Name]): funcontrol.PatternContext = { + case class PatternContext( + override val variables: Seq[any.Name] + ) extends scalaBase.functionalControlOverrides.PatternContext { + def getSelfPatternContext: functionalControlFinalTypes.PatternContext = this + } + PatternContext(variables) + } + def patternVariable(name: any.Name): funcontrol.PatternVariable = { + case class PatternVariable( + override val name:any.Name + ) extends scalaBase.functionalControlOverrides.PatternVariable + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfPatternVariable: functionalControlFinalTypes.PatternVariable = this + } + PatternVariable(name) + } + def constructorPattern(tpe: any.Type, constructor: any.Name, arguments: Seq[any.Expression]): funcontrol.ConstructorPattern = { + case class ConstructorPattern( + override val tpe: any.Type, + override val constructor: any.Name, + override val arguments: Seq[any.Expression] + ) extends scalaBase.functionalControlOverrides.ConstructorPattern + with finalBaseAST.anyOverrides.FinalExpression { + override def getSelfConstructorPattern: functionalControlFinalTypes.ConstructorPattern = this + } + ConstructorPattern(tpe, constructor, arguments) + } + def patternMatch(onValue: any.Expression, cases: Seq[(any.Expression, any.Expression)]): funcontrol.PatternMatch = { + case class PatternMatch( + override val onValue: any.Expression, + override val cases: Seq[(any.Expression, any.Expression)] + ) extends scalaBase.functionalControlOverrides.PatternMatch + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfPatternMatch: functionalControlFinalTypes.PatternMatch = this + } + PatternMatch(onValue, cases) + } + } + + trait PolymorphismFactory extends scalaBase.polymorphismOverrides.Factory { + def typeArgument(name: any.Name): polymorphism.TypeArgument = { + case class TypeArgument(override val name: any.Name) extends scalaBase.polymorphismOverrides.TypeArgument { + def getSelfTypeArgument: polymorphismFinalTypes.TypeArgument = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + TypeArgument(name) + } + def typeApplication(function: any.Type, arguments: Seq[any.Type]): polymorphism.TypeApplication = { + case class TypeApplication(override val function: any.Type, override val arguments: Seq[any.Type]) extends scalaBase.polymorphismOverrides.TypeApplication { + def getSelfTypeApplication: polymorphismFinalTypes.TypeApplication = this + def getSelfType: scalaBase.anyOverrides.Type = this + } + TypeApplication(function, arguments) + } + def typeReferenceExpression(tpe: any.Type): polymorphism.TypeReferenceExpression = { + case class TypeReferenceExpression(override val tpe:any.Type) + extends scalaBase.polymorphismOverrides.TypeReferenceExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfTypeReferenceExpression: polymorphismFinalTypes.TypeReferenceExpression = this + } + TypeReferenceExpression(tpe) + } + } + + trait GenericsFactory extends generics.Factory { + def genericClass(name: any.Name, imports: Seq[any.Import], typeParameters: Seq[polymorphism.TypeParameter], parents: Seq[any.Type], implemented: Seq[any.Type], fields: Seq[oo.Field], methods: Seq[any.Method], constructors: Seq[oo.Constructor], methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type], constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], typeLookupMap: TypeRep => Generator[oo.Class, any.Type], isAbstract: Boolean, isInterface: Boolean, isStatic: Boolean): generics.ooOverrides.Class = { + class GenericClass( + override val name: any.Name, + override val imports: Seq[any.Import], + override val typeParameters: Seq[polymorphism.TypeParameter], + override val parents: Seq[any.Type], + override val implemented: Seq[any.Type], + override val fields: Seq[oo.Field], + override val methods: Seq[any.Method], + override val constructors: Seq[oo.Constructor], + override val methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type], + override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], + override val typeLookupMap: TypeRep => Generator[oo.Class, any.Type], + override val isAbstract: Boolean, + override val isInterface: Boolean, + override val isStatic: Boolean + ) extends scalaBase.ooOverrides.Class { + override def getSelfClass: scalaBase.ooOverrides.Class = this + } + GenericClass(name, imports, typeParameters, parents, implemented, fields, methods, constructors, methodTypeLookupMap, constructorTypeLookupMap, typeLookupMap, isAbstract, isInterface, isStatic) + } + def genericMethod(name: any.Name, imports: Set[any.Import], statements: Seq[any.Statement], returnType: Option[any.Type], typeParameters: Seq[polymorphism.TypeParameter], parameters: Seq[(any.Name, any.Type)], typeLookupMap: TypeRep => Generator[any.Method, any.Type], isAbstract: Boolean, isStatic: Boolean, isPublic: Boolean, isOverride: Boolean): generics.anyOverrides.Method = { + class GenericMethod(override val name: any.Name, + override val imports: Set[any.Import], + override val statements: Seq[any.Statement], + override val returnType: Option[any.Type], + override val typeParameters: Seq[polymorphism.TypeParameter], + override val parameters: Seq[(any.Name, any.Type)], + override val typeLookupMap: TypeRep => Generator[any.Method, any.Type], + override val isAbstract: Boolean, isStatic: Boolean, + override val isPublic: Boolean, + override val isOverride: Boolean) extends scalaBase.anyOverrides.Method { + override def getSelfMethod: scalaBase.anyOverrides.Method = this + } + GenericMethod(name, imports, statements, returnType, typeParameters, parameters, typeLookupMap, isAbstract, isStatic, isPublic, isOverride) + } + def typeParameterWithBounds(name: any.Name, upperBounds: Seq[any.Type], lowerBounds: Seq[any.Type]): generics.polymorphismOverrides.TypeParameter = { + class TypeParameterWithBounds( + override val name: any.Name, + override val upperBounds: Seq[any.Type], + override val lowerBounds: Seq[any.Type] + ) extends scalaBase.polymorphismOverrides.TypeParameter { + override def getSelfTypeParameter: polymorphismFinalTypes.TypeParameter = this + } + TypeParameterWithBounds(name, upperBounds, lowerBounds) + } + } + + trait ImperativeFactory extends scalaBase.imperativeOverrides.Factory { + def declareVariable(name: any.Name, tpe: any.Type, initializer: Option[any.Expression]): imperative.DeclareVariable = { + case class DeclareVariable( + override val name: any.Name, + override val tpe: any.Type, + override val initializer: Option[any.Expression] + ) extends scalaBase.imperativeOverrides.DeclareVariable with finalBaseAST.anyOverrides.FinalStatement { + def getSelfDeclareVariable: imperativeFinalTypes.DeclareVariable = this + } + DeclareVariable(name, tpe, initializer) + } + def variableReferenceExpression(name: any.Name): imperative.VariableReferenceExpression = { + case class VariableReferenceExpression(override val name: any.Name) + extends scalaBase.imperativeOverrides.VariableReferenceExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfVariableReferenceExpression: imperativeFinalTypes.VariableReferenceExpression = this + } + VariableReferenceExpression(name) + } + def assignVariable(variable: any.Expression, expression: any.Expression): imperative.AssignVariable = { + case class AssignVariable(override val variable: any.Expression, override val assignmentExpression: any.Expression) + extends scalaBase.imperativeOverrides.AssignVariable + with finalBaseAST.anyOverrides.FinalStatement { + override def getSelfStatement: scalaBase.anyOverrides.Statement = this + override def getSelfAssignVariable: imperativeFinalTypes.AssignVariable = this + } + AssignVariable(variable, expression) + } + // cannot find LiftExpression in scalaBase.*.LiftExpression + def liftExpression(expression: any.Expression): imperative.LiftExpression = { + case class LiftExpression(override val expression:any.Expression) + extends scalaBase.imperativeOverrides.LiftExpression // NEEDS TO BE OVERRIDE + with finalBaseAST.anyOverrides.FinalStatement { + } + LiftExpression(expression) + } + def ifThenElse(condition: any.Expression, + ifBranch: Seq[any.Statement], + elseIfBranches: Seq[(any.Expression, Seq[any.Statement])], + elseBranch: Seq[any.Statement]): imperative.IfThenElse = { + case class IfThenElse( + override val condition: any.Expression, + override val ifBranch: Seq[any.Statement], + override val elseIfBranches: Seq[(any.Expression, Seq[any.Statement])], + override val elseBranch: Seq[any.Statement]) + extends scalaBase.imperativeOverrides.IfThenElse + with finalBaseAST.anyOverrides.FinalStatement { + def getSelfIfThenElse: imperativeFinalTypes.IfThenElse = this + } + IfThenElse(condition, ifBranch, elseIfBranches, elseBranch) + } + def whileLoop(condition: any.Expression, body: Seq[any.Statement]): imperative.While = { + case class WhileLoop(override val condition: any.Expression, override val body: Seq[any.Statement]) + extends scalaBase.imperativeOverrides.While + with finalBaseAST.anyOverrides.FinalStatement { + def getSelfWhile: imperativeFinalTypes.While = this + } + WhileLoop(condition,body) + } + } + + trait ScalaBaseFactory extends scalaBase.Factory { + def name(name: String, mangled: String): any.Name = { + case class Name(override val component: String, override val mangled: String) extends scalaBase.anyOverrides.Name { + def getSelfName: scalaBase.anyOverrides.Name = this + } + Name(name, mangled) + } + def scalaProject(compilationUnits: Set[any.CompilationUnit], customFiles: Seq[FileWithPath], methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type], constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type], adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type], functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type]): scalaBase.anyOverrides.Project = { + // removed case class to avoid multiple copy implementations + class ScalaProject( + override val compilationUnits: Set[any.CompilationUnit], + override val customFiles: Seq[FileWithPath], + override val methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type], + override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], + override val classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type], + override val adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type], + override val functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type] + ) extends scalaBase.anyOverrides.Project { + def getSelfProject: scalaBase.anyOverrides.Project = this + } + ScalaProject(compilationUnits, customFiles, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap, adtTypeLookupMap, functionTypeLookupMap) + } + def scalaCompilationUnit(name: Seq[any.Name], + imports: Seq[any.Import], + methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type], + constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], + classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type], + adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type], + functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type], + classes: Seq[oo.Class], + adts: Seq[functional.AlgebraicDataType], + functions: Seq[any.Method], + tests: Seq[any.TestSuite]): scalaBase.anyOverrides.CompilationUnit = { + class ScalaCompilationUnit(override val name: Seq[any.Name], + override val imports: Seq[any.Import], + override val methodTypeLookupMap: TypeRep => Generator[any.Method, any.Type], + override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor, any.Type], + override val classTypeLookupMap: TypeRep => Generator[oo.Class, any.Type], + override val adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType, any.Type], + override val functionTypeLookupMap: TypeRep => Generator[any.Method, any.Type], + override val classes: Seq[oo.Class], + override val adts: Seq[functional.AlgebraicDataType], + override val functions: Seq[any.Method], + override val tests: Seq[any.TestSuite]) + extends scalaBase.anyOverrides.CompilationUnit { + def getSelfCompilationUnit: scalaBase.anyOverrides.CompilationUnit = this + } + ScalaCompilationUnit(name, imports, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap, adtTypeLookupMap, functionTypeLookupMap, classes, adts, functions, tests) + } + def importStatement(components: Seq[any.Name]): scalaBase.anyOverrides.Import = { + case class ImportStatement(override val components: Seq[any.Name]) extends scalaBase.anyOverrides.Import { + def getSelfImport: scalaBase.anyOverrides.Import = this + } + ImportStatement(components) + } + def reifiedScalaValue[T](ofHostType: OfHostType[T], value: T): scalaBase.ReifiedScalaValue[T] = { + case class ReifiedScalaValue(override val ofHostType: OfHostType[T], override val value: T) + extends scalaBase.ReifiedScalaValue[T] + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfAsReifiedScalaValue: scalaBaseFinalTypes.ReifiedScalaValue[T] = this + } + ReifiedScalaValue(ofHostType, value) + } + def methodReferenceExpression(qualifiedMethodName: Seq[any.Name]): scalaBase.MethodReferenceExpression = { + case class MethodReferenceExpression(override val qualifiedMethodName: Seq[any.Name]) + extends scalaBase.MethodReferenceExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfAsMethodReferenceExpression: scalaBaseFinalTypes.MethodReferenceExpression = this + } + MethodReferenceExpression(qualifiedMethodName) + } + def blockExpression(statements: Seq[any.Statement]): scalaBase.BlockExpression = { + case class BlockExpression (override val statements: Seq[any.Statement]) + extends scalaBase.BlockExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfBlockExpression: scalaBaseFinalTypes.BlockExpression = this + } + BlockExpression(statements) + } + } + } + + override val factory: scalaBase.anyOverrides.Factory = new FinalBaseFactoryTypes.Factory {} + override val ooFactory: scalaBase.ooOverrides.Factory = new FinalBaseFactoryTypes.OOFactory {} + override val functionalFactory: scalaBase.functionalOverrides.Factory = new FinalBaseFactoryTypes.FunctionalFactory {} + override val functionalControlFactory: scalaBase.functionalControlOverrides.Factory = new FinalBaseFactoryTypes.FunctionalControlFactory {} + override val polymorphismFactory: scalaBase.polymorphismOverrides.Factory = new FinalBaseFactoryTypes.PolymorphismFactory {} + override val imperativeFactory: scalaBase.imperativeOverrides.Factory = new FinalBaseFactoryTypes.ImperativeFactory {} + override val genericsFactory: generics.Factory = new FinalBaseFactoryTypes.GenericsFactory {} + override val scalaBaseFactory: scalaBase.Factory = new FinalBaseFactoryTypes.ScalaBaseFactory {} +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/NameProviderAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/NameProviderAST.scala new file mode 100644 index 00000000..501f7ed4 --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/NameProviderAST.scala @@ -0,0 +1,91 @@ +package org.combinators.ep.language.scala.ast + +import com.github.javaparser.{JavaParser, StaticJavaParser} +import org.combinators.cogen.NameProvider +import org.combinators.ep.language.inbetween.any +import scala.util.Try + +trait NameProviderAST { self: BaseAST => + object nameProvider { + trait FinalTypes { + type NameProvider <: nameProvider.ScalaNameProvider + } + + trait ScalaNameProvider extends NameProvider[any.Name] { + def getSelfNameProvider: nameProviderFinalTypes.NameProvider + + val parser = new JavaParser(StaticJavaParser.getParserConfiguration) + + /** Need to have single-param version so this can be used in map. */ + def mangle(name: String): any.Name = { + mangle(name, Set("Object", "hashCode", "equals", "toString", "getClass", "type")) + } + + /** Tries to parse names as a + * [[https://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.2 simple Java name]] and mangles to + * the arabic number representation of the UTF-8 bytes in the given string, where each byte is prefixed by "_". + * + * Example: + * {{ + * JavaNameProvider.mangle("foo") // returns "foo" + * JavaNameProvider.mangle("class") // returns "_99_108_97_115_115" because "class" is a reserved keyword + * }} + */ + def mangle(name: String, forbidden: Set[String]): any.Name = { + var cleanName = name + + // some default methods in java.lang.Object CANNOT be overridden as needed by some AIPs, so + // take steps to avoid special java methods. To ensure 'equals' and other FFI-required names + // go through unchanged, we allow for optional parameter to eliminate. + while (forbidden.contains(cleanName)) { + cleanName = "_" + cleanName + } + + self.scalaBaseFactory.name(name, Try(parser.parseSimpleName(cleanName).getResult.map[String](_.getIdentifier).get).getOrElse { + cleanName.getBytes(java.nio.charset.StandardCharsets.UTF_8).mkString("_", "_", "") + } + ) + } + + def addPrefix(prefix: String, name: any.Name): any.Name = { + mangle(prefix + factory.convert(name).component) + } + + def addSuffix(name: any.Name, suffix: String): any.Name = { + mangle(factory.convert(name).component + suffix) + } + } + + trait Factory { + def scalaNameProvider: nameProvider.ScalaNameProvider + + implicit def convert(other: nameProvider.ScalaNameProvider): nameProviderFinalTypes.NameProvider = + other.getSelfNameProvider + } + } + + val nameProviderFinalTypes: nameProvider.FinalTypes + val nameProviderFactory: nameProvider.Factory +} + +trait FinalNameProviderAST extends NameProviderAST { self: BaseAST => + object finalNameProviderFinalTypes { + trait NameProviderFinalTypes extends nameProvider.FinalTypes { + type NameProvider = nameProvider.ScalaNameProvider + } + } + + object finalNameProviderFactoryTypes { + trait NameProviderFactory extends nameProvider.Factory { + def scalaNameProvider: nameProvider.ScalaNameProvider = { + case class ScalaNameProvider() extends nameProvider.ScalaNameProvider { + override def getSelfNameProvider: nameProvider.ScalaNameProvider = this + } + ScalaNameProvider() + } + } + } + + override val nameProviderFinalTypes: finalNameProviderFinalTypes.NameProviderFinalTypes = new finalNameProviderFinalTypes.NameProviderFinalTypes {} + override val nameProviderFactory: finalNameProviderFactoryTypes.NameProviderFactory = new finalNameProviderFactoryTypes.NameProviderFactory {} +} \ No newline at end of file diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/ArithmeticAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/ArithmeticAST.scala new file mode 100644 index 00000000..5a60c138 --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/ArithmeticAST.scala @@ -0,0 +1,96 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.{ArithmeticAST => InbetweenArithmeticOpsAST} +import org.combinators.ep.language.scala.ast.BaseAST +import org.combinators.ep.language.scala.ast.ffi.OperatorExpressionsAST + +trait ArithmeticAST extends InbetweenArithmeticOpsAST { self: OperatorExpressionsAST & BaseAST => + object scalaArithmeticOps { + object arithmeticOpsOverride { + + trait AddOp + extends arithmeticOps.AddOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "+" + } + trait SubOp extends arithmeticOps.SubOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "-" + } + trait MultOp extends arithmeticOps.MultOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "*" + } + trait DivOp extends arithmeticOps.DivOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "/" + } + trait ModOp extends arithmeticOps.ModOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "%" + } + trait LtOp extends arithmeticOps.LtOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "<" + } + trait LeOp extends arithmeticOps.LeOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "<=" + } + + trait Factory extends arithmeticOps.Factory {} + } + } + val arithmeticOpsFactory: scalaArithmeticOps.arithmeticOpsOverride.Factory +} + +trait FinalArithmeticAST extends ArithmeticAST { self: FinalOperatorExpressionsAST & BaseAST => + object finalArithmeticFactoryTypes { + trait FinalArithmeticFactory extends scalaArithmeticOps.arithmeticOpsOverride.Factory { + def addOp(): arithmeticOps.AddOp = { + case class AddOp() extends scalaArithmeticOps.arithmeticOpsOverride.AddOp + with finalOperatorExpressions .operatorExpressionsOverrides.Operator {} + AddOp() + } + def subOp(): arithmeticOps.SubOp = { + case class SubOp() extends scalaArithmeticOps.arithmeticOpsOverride.SubOp + with finalOperatorExpressions .operatorExpressionsOverrides.Operator {} + SubOp() + } + def multOp(): arithmeticOps.MultOp = { + case class MultOp() extends scalaArithmeticOps.arithmeticOpsOverride.MultOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + MultOp() + } + def divOp(): arithmeticOps.DivOp = { + case class DivOp() extends scalaArithmeticOps.arithmeticOpsOverride.DivOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + DivOp() + } + def modOp(): arithmeticOps.ModOp = { + case class ModOp() extends scalaArithmeticOps.arithmeticOpsOverride.ModOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + ModOp() + } + def ltOp(): arithmeticOps.LtOp = { + case class LtOp() extends scalaArithmeticOps.arithmeticOpsOverride.LtOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + LtOp() + } + def leOp(): arithmeticOps.LeOp = { + case class LeOp() extends scalaArithmeticOps.arithmeticOpsOverride.LeOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + LeOp() + } + } + } + + val arithmeticOpsFactory: finalArithmeticFactoryTypes.FinalArithmeticFactory = new finalArithmeticFactoryTypes.FinalArithmeticFactory {} +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/AssertionsAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/AssertionsAST.scala new file mode 100644 index 00000000..7252ed4f --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/AssertionsAST.scala @@ -0,0 +1,37 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.{AssertionsAST => InbetweenAssertionsAST} +import org.combinators.ep.language.scala.ast.BaseAST +import org.combinators.ep.language.scala.ast.ffi.OperatorExpressionsAST + +trait AssertionsAST extends InbetweenAssertionsAST { self: OperatorExpressionsAST & BaseAST => + object scalaAssertions { + object assertionOpsOverride { + trait AssertTrueOp extends assertionOps.AssertTrueOp with scalaOperatorExpressions.operatorExpressionsOverrides.Operator { + import factory.* + def operator: String = "assert " + def toScala(operands: any.Expression*): String = s"assert (${operands.head.toScala})" + } + + trait Factory extends assertionOps.Factory {} + } + } + val assertionOpsFactory: scalaAssertions.assertionOpsOverride.Factory +} + +trait FinalAssertionsAST extends AssertionsAST { self: FinalOperatorExpressionsAST & BaseAST => + object finalAssertionsFactoryTypes { + trait AssertionsFactory extends scalaAssertions.assertionOpsOverride.Factory { + def assertTrueOp(): scalaAssertions.assertionOpsOverride.AssertTrueOp = { + case class AssertTrueOp() extends scalaAssertions.assertionOpsOverride.AssertTrueOp { + + def getSelfOperator: operatorExpressionsFinalTypes.Operator = this + } + + AssertTrueOp() + } + } + } + + val assertionOpsFactory: finalAssertionsFactoryTypes.AssertionsFactory = new finalAssertionsFactoryTypes.AssertionsFactory {} +} \ No newline at end of file diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/BooleanAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/BooleanAST.scala new file mode 100644 index 00000000..1ead8c05 --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/BooleanAST.scala @@ -0,0 +1,75 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.{BooleanAST => InbetweenBooleanAST} +import org.combinators.ep.language.scala.ast.{BaseAST, FinalBaseAST} +import org.combinators.ep.language.scala.ast.ffi.OperatorExpressionsAST + +trait BooleanAST extends InbetweenBooleanAST { self: OperatorExpressionsAST & BaseAST => + object scalaBooleanOps { + object booleanOpsOverride { + + trait AndOp + extends booleanOps.AndOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "&&" + } + trait OrOp extends booleanOps.OrOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "||" + } + trait NotOp extends booleanOps.NotOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.PrefixOperator { + override def operator: String = "!" + } + trait True extends booleanOps.True with scalaBase.anyOverrides.Expression { + def toScala: String = "true" + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Expression = this + } + trait False extends booleanOps.False with scalaBase.anyOverrides.Expression { + def toScala: String = "false" + def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): any.Expression = this + } + + trait Factory extends booleanOps.Factory {} + } + } + + override val booleanOpsFactory: scalaBooleanOps.booleanOpsOverride.Factory +} + +trait FinalBooleanAST extends BooleanAST { self: FinalOperatorExpressionsAST & FinalBaseAST => + object finalBooleanFactoryTypes { + trait FinalBooleanFactory extends scalaBooleanOps.booleanOpsOverride.Factory { + def andOp(): booleanOps.AndOp = { + case class AndOp() extends scalaBooleanOps.booleanOpsOverride.AndOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + AndOp() + } + def orOp(): booleanOps.OrOp = { + case class OrOp() extends scalaBooleanOps.booleanOpsOverride.OrOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + OrOp() + } + def notOp(): booleanOps.NotOp = { + case class NotOp() extends scalaBooleanOps.booleanOpsOverride.NotOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + NotOp() + } + def trueExp(): booleanOps.True = { + case class True() extends scalaBooleanOps.booleanOpsOverride.True + with finalBaseAST.anyOverrides.FinalExpression {} + True() + } + def falseExp(): booleanOps.False = { + case class False() extends scalaBooleanOps.booleanOpsOverride.False + with finalBaseAST.anyOverrides.FinalExpression {} + False() + } + } + } + + val booleanOpsFactory: finalBooleanFactoryTypes.FinalBooleanFactory = new finalBooleanFactoryTypes.FinalBooleanFactory {} +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/EqualsAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/EqualsAST.scala new file mode 100644 index 00000000..086e10fe --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/EqualsAST.scala @@ -0,0 +1,41 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.{EqualsAST => InbetweenEqualsAST} +import org.combinators.ep.language.scala.ast.{BaseAST, FinalBaseAST} + +trait EqualsAST extends InbetweenEqualsAST { self: BaseAST => + object scalaEqualsOp { + object equalsOpOverride { + trait Equals extends equalsOp.Equals with scalaBase.anyOverrides.Expression { + import factory.* + def toScala: String = s"${left.toScala} == ${right.toScala}" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): equalsOp.Equals = + copy( + tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), + left = left.prefixRootPackage(rootPackageName, excludedTypeNames), + right = right.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait Factory extends equalsOp.Factory {} + } + } + + override val equalsOpFactory: scalaEqualsOp.equalsOpOverride.Factory +} + +trait FinalEqualsAST extends EqualsAST { + self: FinalBaseAST => + object finalEqualsFactoryTypes { + trait EqualsOpFactory extends scalaEqualsOp.equalsOpOverride.Factory { + def equals(tpe: any.Type, left: any.Expression, right: any.Expression): equalsOp.Equals = { + case class Equals(override val tpe: any.Type, override val left: any.Expression, override val right: any.Expression) extends scalaEqualsOp.equalsOpOverride.Equals + with finalBaseAST.anyOverrides.FinalExpression {} + Equals(tpe, left, right) + } + } + } + + override val equalsOpFactory: scalaEqualsOp.equalsOpOverride.Factory = new finalEqualsFactoryTypes.EqualsOpFactory {} +} \ No newline at end of file diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/ListsAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/ListsAST.scala new file mode 100644 index 00000000..57322391 --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/ListsAST.scala @@ -0,0 +1,70 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.ListsAST as InbetweenListsAST +import org.combinators.ep.language.scala.ast.{BaseAST, FinalBaseAST} + +trait ListsAST extends InbetweenListsAST { self: OperatorExpressionsAST & BaseAST => + object scalaListsOps { + object listsOpsOverride { + + trait CreateList extends listsOps.CreateList with scalaBase.anyOverrides.Type { + override def toScala: String = "Seq" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): CreateList = + this + def toImport: Seq[any.Import] = Seq.empty + } + + trait ConsListOp extends listsOps.ConsListOp with scalaOperatorExpressions.operatorExpressionsOverrides.Operator with scalaOperatorExpressions.InfixOperator { + def operator: String = "+:" + } + + trait HeadListOp extends listsOps.HeadListOp with scalaOperatorExpressions.operatorExpressionsOverrides.Operator with scalaOperatorExpressions.PostfixOperator { + def operator: String = ".head" + } + + trait TailListOp extends listsOps.TailListOp with scalaOperatorExpressions.operatorExpressionsOverrides.Operator with scalaOperatorExpressions.PostfixOperator { + def operator: String = ".tail" + } + + trait AppendListOp extends listsOps.AppendListOp with scalaOperatorExpressions.operatorExpressionsOverrides.Operator with scalaOperatorExpressions.InfixOperator { + def operator: String = "++" + } + + trait Factory extends listsOps.Factory {} + } + } + + override val listsOpsFactory: scalaListsOps.listsOpsOverride.Factory +} + +trait FinalListsAST extends ListsAST { self: FinalOperatorExpressionsAST & FinalBaseAST => + object finalListsFactoryTypes { + trait FinalListsFactory extends scalaListsOps.listsOpsOverride.Factory { + def createList(): listsOps.CreateList = { + case class CreateList() extends scalaListsOps.listsOpsOverride.CreateList { + def getSelfType: scalaBase.anyOverrides.Type = this + } + CreateList() + } + def consListOp(): listsOps.ConsListOp = { + case class ConsListOp() extends scalaListsOps.listsOpsOverride.ConsListOp with finalOperatorExpressions.operatorExpressionsOverrides.Operator + ConsListOp() + } + def headListOp(): listsOps.HeadListOp = { + case class HeadListOp() extends scalaListsOps.listsOpsOverride.HeadListOp with finalOperatorExpressions.operatorExpressionsOverrides.Operator + HeadListOp() + } + def tailListOp(): listsOps.TailListOp = { + case class TailListOp() extends scalaListsOps.listsOpsOverride.TailListOp with finalOperatorExpressions.operatorExpressionsOverrides.Operator + TailListOp() + } + def appendListOp(): listsOps.AppendListOp = { + case class AppendListOp() extends scalaListsOps.listsOpsOverride.AppendListOp with finalOperatorExpressions.operatorExpressionsOverrides.Operator + AppendListOp() + } + } + } + + val listsOpsFactory: finalListsFactoryTypes.FinalListsFactory = new finalListsFactoryTypes.FinalListsFactory {} +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/OperatorExpressionsAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/OperatorExpressionsAST.scala new file mode 100644 index 00000000..26539fa9 --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/OperatorExpressionsAST.scala @@ -0,0 +1,116 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.{OperatorExpressionOpsAST => InbetweenOperatorExpressionOpsAST} +import org.combinators.ep.language.scala.ast.{BaseAST, FinalBaseAST} + +trait OperatorExpressionsAST extends InbetweenOperatorExpressionOpsAST{ self: BaseAST => + object scalaOperatorExpressions { + object operatorExpressionsOverrides { + trait FinalTypes extends operatorExpressions.FinalTypes { + type Operator <: operatorExpressionsOverrides.Operator + type BinaryExpression <: operatorExpressionsOverrides.BinaryExpression + type UnaryExpression <: operatorExpressionsOverrides.UnaryExpression + } + + trait BinaryExpression extends scalaBase.anyOverrides.Expression with operatorExpressions.BinaryExpression { + + def toScala: String = s"(${operator.getSelfOperator.toScala(left, right)})" // necessary when composing expressions, though can get excessive at times. + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): operatorExpressions.BinaryExpression = + copy( + left = left.getSelfExpression.prefixRootPackage(rootPackageName, excludedTypeNames), + right = right.getSelfExpression.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait UnaryExpression extends scalaBase.anyOverrides.Expression with operatorExpressions.UnaryExpression { + def toScala: String = operator.getSelfOperator.toScala(operand) + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): operatorExpressions.UnaryExpression = + copy( + operand = operand.getSelfExpression.prefixRootPackage(rootPackageName, excludedTypeNames) + ) + } + + trait Operator extends operatorExpressions.Operator { + def toScala(operands: any.Expression*): String + } + + trait Factory extends operatorExpressions.Factory {} + } + + trait InfixOperator { + def operator: String + def toScala(operands: any.Expression*): String = operands.map(_.getSelfExpression.toScala).mkString(operator) + } + + trait PrefixOperator { + def operator: String + def toScala(operands: any.Expression*): String = s"($operator${operands.head.getSelfExpression.toScala})" + } + + trait MathFunctionOperator { + import factory.* + def operator: String + def toScala(operands: any.Expression*): String = { + s"Math.$operator${operands.map(_.getSelfExpression.toScala).mkString("(", ", ", ")")}" + } + } + + trait PostfixOperator { + import factory.* + def operator: String + def toScala(operands: any.Expression*): String = s"(${operands.head.getSelfExpression.toScala}$operator)" + } + } + + val operatorExpressionsFinalTypes: scalaOperatorExpressions.operatorExpressionsOverrides.FinalTypes + val operatorExpressionsFactory: scalaOperatorExpressions.operatorExpressionsOverrides.Factory +} + +trait FinalOperatorExpressionsAST extends OperatorExpressionsAST { self: FinalBaseAST => + + object finalOperatorExpressions { + object operatorExpressionsOverrides { + trait Operator extends scalaOperatorExpressions.operatorExpressionsOverrides.Operator { + def getSelfOperator: scalaOperatorExpressions.operatorExpressionsOverrides.Operator = this + } + } + } + + object finalOperatorExpressionsFinalTypes { + trait OperatorExpressionsFinalTypes extends scalaOperatorExpressions.operatorExpressionsOverrides.FinalTypes { + type Operator = scalaOperatorExpressions.operatorExpressionsOverrides.Operator + type BinaryExpression = scalaOperatorExpressions.operatorExpressionsOverrides.BinaryExpression + type UnaryExpression = scalaOperatorExpressions.operatorExpressionsOverrides.UnaryExpression + } + } + override val operatorExpressionsFinalTypes: finalOperatorExpressionsFinalTypes.OperatorExpressionsFinalTypes = new finalOperatorExpressionsFinalTypes.OperatorExpressionsFinalTypes {} + + object finalOperatorExpressionsFactoryTypes { + trait OperatorExpressionsFactory extends scalaOperatorExpressions.operatorExpressionsOverrides.Factory { + def binaryExpression(operator: operatorExpressions.Operator, left: any.Expression, right: any.Expression): operatorExpressions.BinaryExpression = { + case class BinaryExpression( + override val operator: operatorExpressions.Operator, + override val left: any.Expression, + override val right: any.Expression) + extends scalaOperatorExpressions.operatorExpressionsOverrides.BinaryExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfBinaryExpression: scalaOperatorExpressions.operatorExpressionsOverrides.BinaryExpression = this + } + BinaryExpression(operator, left, right) + } + def unaryExpression(operator: operatorExpressions.Operator, operand: any.Expression): operatorExpressions.UnaryExpression = { + case class UnaryExpression( + override val operator: operatorExpressions.Operator, + override val operand: any.Expression) + extends scalaOperatorExpressions.operatorExpressionsOverrides.UnaryExpression + with finalBaseAST.anyOverrides.FinalExpression { + def getSelfUnaryExpression: scalaOperatorExpressions.operatorExpressionsOverrides.UnaryExpression = this + } + UnaryExpression(operator, operand) + } + } + } + override val operatorExpressionsFactory: scalaOperatorExpressions.operatorExpressionsOverrides.Factory = new finalOperatorExpressionsFactoryTypes.OperatorExpressionsFactory {} +} \ No newline at end of file diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/RealArithmeticAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/RealArithmeticAST.scala new file mode 100644 index 00000000..33bcee0e --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/RealArithmeticAST.scala @@ -0,0 +1,130 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.RealArithmeticAST as InbetweenRealArithmeticAST +import org.combinators.ep.language.scala.ast.{BaseAST, FinalBaseAST} +import org.combinators.ep.language.scala.ast.ffi.OperatorExpressionsAST + +trait RealArithmeticOpsAST extends InbetweenRealArithmeticAST { self: OperatorExpressionsAST & BaseAST => + object scalaRealArithmeticOps { + object realArithmeticOpsOverride { + + trait SqrtOp + extends realArithmeticOps.SqrtOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + override def operator: String = "sqrt" + } + + trait PowOp extends realArithmeticOps.PowOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + override def operator: String = "pow" + } + + trait LogOp extends realArithmeticOps.LogOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + import factory.* + override def operator: String = "log" + override def toScala(operands: any.Expression*): String = { + s"(Math.$operator(${operands(0).toScala})/Math.$operator(${operands(1).toScala}))" + } + } + + trait SinOp extends realArithmeticOps.SinOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + override def operator: String = "sin" + } + + trait CosOp extends realArithmeticOps.CosOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + override def operator: String = "cos" + } + + trait AbsOp extends realArithmeticOps.AbsOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + override def operator: String = "abs" + } + + trait FloorOp extends realArithmeticOps.FloorOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.MathFunctionOperator { + override def operator: String = "floor" + } + + trait EulersNumber extends realArithmeticOps.EulersNumber with scalaBase.anyOverrides.Expression { + override def toScala: String = "Math.E" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): EulersNumber = + this + } + + trait Pi extends realArithmeticOps.Pi with scalaBase.anyOverrides.Expression{ + override def toScala: String = "Math.PI" + + override def prefixRootPackage(rootPackageName: Seq[any.Name], excludedTypeNames: Set[Seq[any.Name]]): Pi = + this + } + + trait Factory extends realArithmeticOps.Factory {} + } + } + val realArithmeticOpsFactory: scalaRealArithmeticOps.realArithmeticOpsOverride.Factory +} + +trait FinalRealArithmeticOpsAST extends RealArithmeticOpsAST { self: FinalOperatorExpressionsAST & FinalBaseAST => + object finalRealArithmeticFactoryTypes { + trait FinalRealArithmeticFactory extends scalaRealArithmeticOps.realArithmeticOpsOverride.Factory { + def sqrtOp(): realArithmeticOps.SqrtOp = { + case class SqrtOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.SqrtOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + SqrtOp() + } + def powOp(): realArithmeticOps.PowOp = { + case class PowOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.PowOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + PowOp() + } + def logOp(): realArithmeticOps.LogOp = { + case class LogOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.LogOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + LogOp() + } + def sinOp(): realArithmeticOps.SinOp = { + case class SinOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.SinOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + SinOp() + } + def cosOp(): realArithmeticOps.CosOp = { + case class CosOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.CosOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + CosOp() + } + def absOp(): realArithmeticOps.AbsOp = { + case class AbsOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.AbsOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + AbsOp() + } + def floorOp(): realArithmeticOps.FloorOp= { + case class FloorOp() extends scalaRealArithmeticOps.realArithmeticOpsOverride.FloorOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + FloorOp() + } + def pi(): realArithmeticOps.Pi = { + case class Pi() extends scalaRealArithmeticOps.realArithmeticOpsOverride.Pi + with finalBaseAST.anyOverrides.FinalExpression {} + Pi() + } + def eulersNumber(): realArithmeticOps.EulersNumber = { + case class EulersNumber() extends scalaRealArithmeticOps.realArithmeticOpsOverride.EulersNumber + with finalBaseAST.anyOverrides.FinalExpression {} + EulersNumber() + } + } + } + + val realArithmeticOpsFactory: finalRealArithmeticFactoryTypes.FinalRealArithmeticFactory = new finalRealArithmeticFactoryTypes.FinalRealArithmeticFactory {} +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/StringAST.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/StringAST.scala new file mode 100644 index 00000000..7d3df25b --- /dev/null +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/ast/ffi/StringAST.scala @@ -0,0 +1,58 @@ +package org.combinators.ep.language.scala.ast.ffi + +import org.combinators.ep.language.inbetween.ffi.StringAST as InbetweenStringsAST +import org.combinators.ep.language.scala.ast.BaseAST +import org.combinators.ep.language.scala.ast.ffi.OperatorExpressionsAST + +trait StringAST extends InbetweenStringsAST { self: OperatorExpressionsAST & BaseAST => + object scalaStringOps { + object stringOpsOverride { + + trait ToStringOp extends stringOps.ToStringOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.PostfixOperator { + override def operator: String = ".toString()" + } + + trait AppendStringOp extends stringOps.AppendStringOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.InfixOperator { + override def operator: String = "++" + } + + trait StringLengthOp extends stringOps.StringLengthOp + with scalaOperatorExpressions.operatorExpressionsOverrides.Operator + with scalaOperatorExpressions.PostfixOperator { + override def operator: String = ".length" + } + + trait Factory extends stringOps.Factory {} + } + } + + override val stringOpsFactory: scalaStringOps.stringOpsOverride.Factory +} + +trait FinalStringAST extends StringAST { self: FinalOperatorExpressionsAST & BaseAST => + object finalStringsFactoryTypes { + trait FinalStringsFactory extends scalaStringOps.stringOpsOverride.Factory { + def toStringOp(): stringOps.ToStringOp = { + case class ToStringOp() extends scalaStringOps.stringOpsOverride.ToStringOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + ToStringOp() + } + def appendStringOp(): stringOps.AppendStringOp = { + case class AppendStringOp() extends scalaStringOps.stringOpsOverride.AppendStringOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + AppendStringOp() + } + def stringLengthOp(): stringOps.StringLengthOp = { + case class StringLengthOp() extends scalaStringOps.stringOpsOverride.StringLengthOp + with finalOperatorExpressions.operatorExpressionsOverrides.Operator {} + StringLengthOp() + } + } + } + + override val stringOpsFactory: finalStringsFactoryTypes.FinalStringsFactory = new finalStringsFactoryTypes.FinalStringsFactory {} +} diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/CodeGenerator.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/CodeGenerator.scala index e620372b..c61afa27 100644 --- a/language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/CodeGenerator.scala +++ b/language/newScala/src/main/scala/org/combinators/ep/language/scala/codegen/CodeGenerator.scala @@ -1,80 +1,86 @@ -package org.combinators.ep.language.scala.codegen /*DI:LD:AI*/ - -import cats.{Apply => _} -import org.combinators.ep.domain.GenericModel -import org.combinators.ep.generator.{Command, FileWithPath, Understands} -import org.combinators.ep.language.scala.{Finalized, ScalaNameProvider} -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.generator -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.paradigm.{Apply, ToTargetLanguageType} -import org.combinators.ep.language.inbetween.any.{AbstractSyntax, CompilationUnit, AnyParadigm, Method, Name, Project, Type} -import org.combinators.ep.language.inbetween.oo.{Class, Constructor, OOParadigm} +package org.combinators.ep.language.scala.codegen + +/*DI:LD:AI*/ + +import cats.Apply as _ +import org.combinators.cogen.Command.Generator +import org.combinators.cogen.paradigm.{Apply, ToTargetLanguageType} +import org.combinators.cogen.{Command, FileWithPath, TypeRep, Understands} +import org.combinators.ep.language.inbetween.any.* +import org.combinators.ep.language.inbetween.any.AnyParadigm.WithSyntax +import org.combinators.ep.language.inbetween.ffi.* +import org.combinators.ep.language.inbetween.functional.control.Functional.WithBase +import org.combinators.ep.language.inbetween.functional.{FunctionalParadigm, control} import org.combinators.ep.language.inbetween.imperative.Imperative -import org.combinators.ep.language.inbetween.functional.{AlgebraicDataType, FunctionalParadigm} -import org.combinators.ep.language.inbetween.functional.control -import org.combinators.ep.language.inbetween.ffi.{Arithmetic, RealArithmetic, Booleans, Equals, Lists, Trees, Strings, Assertions} -import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphism -import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphismInADTContexts +import org.combinators.ep.language.inbetween.oo.OOParadigm import org.combinators.ep.language.inbetween.polymorphism.generics.Generics +import org.combinators.ep.language.inbetween.polymorphism.{ParametricPolymorphism, ParametricPolymorphismInADTContexts} +import org.combinators.ep.language.scala.ast.ffi.ArithmeticAST +import org.combinators.ep.language.scala.ast.{BaseAST, NameProviderAST} import java.nio.file.{Path, Paths} +type FullAST = BaseAST + & NameProviderAST + & ArithmeticAST + & AssertionsAST + & BooleanAST + & EqualsAST + & ListsAST + & OperatorExpressionOpsAST + & RealArithmeticAST + & StringAST /** * Scala-specific. * * These paradigm-specific traits are conceptually different from each other */ -sealed class CodeGenerator(domainName: String) { cc => - val factory: Finalized.Factory = new Finalized.Factory {} +sealed class CodeGenerator[AST <: FullAST](val domainName: String, val ast: AST, additionalPrefixExcludedTypes: Set[Seq[ast.any.Name]] = Set.empty) { cc => + val syntax: AbstractSyntax.AbstractSyntax[ast.type] = AbstractSyntax(ast) + val nameProvider: ast.nameProvider.ScalaNameProvider = ast.nameProviderFactory.scalaNameProvider - - val syntax: AbstractSyntax[Finalized.FinalTypes] = new AbstractSyntax[Finalized.FinalTypes] {} - val nameProvider = new ScalaNameProvider[Finalized.FinalTypes](factory) - - def toLookup[Ctxt](name: String*): Option[Generator[Ctxt, Type[Finalized.FinalTypes]]] = { - Some(Command.lift(factory.classReferenceType(name.map(nameProvider.mangle):_*))) + def toLookup[Ctxt](name: String*): Option[Generator[Ctxt, ast.any.Type]] = { + Some(Command.lift(ast.ooFactory.classReferenceType(name.map(nameProvider.mangle)*))) } def addLookupsForImplementedGenerators[Ctxt]( - project: Project[Finalized.FinalTypes], - add: (Project[Finalized.FinalTypes], TypeRep => Option[Generator[Ctxt, Type[Finalized.FinalTypes]]]) => Project[Finalized.FinalTypes] - )(implicit canToTargetLanguage: Understands[Ctxt, ToTargetLanguageType[Type[Finalized.FinalTypes]]], - canApplyType: Understands[Ctxt, Apply[Type[Finalized.FinalTypes], Type[Finalized.FinalTypes], Type[Finalized.FinalTypes]]] - ): Project[Finalized.FinalTypes] = { + project: ast.any.Project, + add: (ast.any.Project, TypeRep => Option[Generator[Ctxt, ast.any.Type]]) => ast.any.Project + )(implicit canToTargetLanguage: Understands[Ctxt, ToTargetLanguageType[ast.any.Type]], + canApplyType: Understands[Ctxt, Apply[ast.any.Type, ast.any.Type, ast.any.Type]] + ): ast.any.Project = { add(project, { case TypeRep.Double => toLookup("Double") case TypeRep.Int => toLookup("Int") case TypeRep.Boolean => toLookup("Boolean") case TypeRep.String => toLookup("String") case TypeRep.Unit => toLookup("Unit") - case TypeRep.Tree => toLookup("org", "combinators", "ep", "util", "Tree") case TypeRep.Sequence(elemTpeRep) => Some( for { - elemTpe <- ToTargetLanguageType[Type[Finalized.FinalTypes]](elemTpeRep).interpret(canToTargetLanguage) - seqTpe <- Command.lift(factory.classReferenceType(nameProvider.mangle("Seq"))) + elemTpe <- ToTargetLanguageType[ast.any.Type](elemTpeRep).interpret(canToTargetLanguage) + seqTpe <- Command.lift(ast.ooFactory.classReferenceType(nameProvider.mangle("Seq"))) tpe <- Apply[ - Type[Finalized.FinalTypes], - Type[Finalized.FinalTypes], - Type[Finalized.FinalTypes]](seqTpe, Seq(elemTpe)).interpret(canApplyType) + ast.any.Type, + ast.any.Type, + ast.any.Type](seqTpe, Seq(elemTpe)).interpret(canApplyType) } yield tpe) case TypeRep.Arrow(src, tgt) => Some( for { - srcTpe <- ToTargetLanguageType[Type[Finalized.FinalTypes]](src).interpret(canToTargetLanguage) - tgtTpe <- ToTargetLanguageType[Type[Finalized.FinalTypes]](tgt).interpret(canToTargetLanguage) - funTpe <- Command.lift(factory.classReferenceType(nameProvider.mangle("Function"))) + srcTpe <- ToTargetLanguageType[ast.any.Type](src).interpret(canToTargetLanguage) + tgtTpe <- ToTargetLanguageType[ast.any.Type](tgt).interpret(canToTargetLanguage) + funTpe <- Command.lift(ast.ooFactory.classReferenceType(nameProvider.mangle("Function"))) tpe <- Apply[ - Type[Finalized.FinalTypes], - Type[Finalized.FinalTypes], - Type[Finalized.FinalTypes]](funTpe, Seq(srcTpe, tgtTpe)).interpret(canApplyType) + ast.any.Type, + ast.any.Type, + ast.any.Type](funTpe, Seq(srcTpe, tgtTpe)).interpret(canApplyType) } yield tpe) case _ => None }) } - def prefixExcludedTypes: Set[Seq[Name[Finalized.FinalTypes]]] = { + def prefixExcludedTypes: Set[Seq[ast.any.Name]] = { Set( Seq("Double"), Seq("Boolean"), @@ -83,14 +89,11 @@ sealed class CodeGenerator(domainName: String) { cc => Seq("String"), Seq("Seq"), Seq("Function"), - Seq("org", "combinators", "ep", "util", "Tree"), - Seq("org", "combinators", "ep", "util", "Node"), - Seq("org", "combinators", "ep", "util", "Leaf") - ).map(qname => qname.map(nameProvider.mangle)) + ).map(qname => qname.map(nameProvider.mangle)) ++ additionalPrefixExcludedTypes } - def runGenerator(generator: Generator[Project[Finalized.FinalTypes], Unit]): Seq[FileWithPath] = { - var projectWithLookups: Project[Finalized.FinalTypes] = factory.scalaProject(Set.empty) + def runGenerator(generator: Generator[ast.any.Project, Unit]): Seq[FileWithPath] = { + var projectWithLookups: ast.any.Project = ast.scalaBaseFactory.scalaProject(Set.empty) def buildFile: FileWithPath = { // create a rudimentary build.sbt for Scala just to work with sbt version 1.7.1 @@ -137,44 +140,44 @@ sealed class CodeGenerator(domainName: String) { cc => projectWithLookups = - addLookupsForImplementedGenerators[Method[Finalized.FinalTypes]]( - factory.convert(projectWithLookups), - { case (project, lookup) => factory.convert(project).addTypeLookupsForMethods(lookup) } + addLookupsForImplementedGenerators[ast.any.Method]( + ast.factory.convert(projectWithLookups), + { case (project, lookup) => ast.factory.convert(project).addTypeLookupsForMethods(lookup) } )(paradigm.methodBodyCapabilities.canTransformTypeInMethodBody, parametricPolymorphism.methodBodyCapabilities.canApplyTypeInMethod) projectWithLookups = - addLookupsForImplementedGenerators[Method[Finalized.FinalTypes]]( - factory.convert(projectWithLookups), - { case (project, lookup) => factory.convert(project).addTypeLookupsForFunctions(lookup) } + addLookupsForImplementedGenerators[ast.any.Method]( + ast.factory.convert(projectWithLookups), + { case (project, lookup) => ast.factory.convert(project).addTypeLookupsForFunctions(lookup) } )(paradigm.methodBodyCapabilities.canTransformTypeInMethodBody, parametricPolymorphism.methodBodyCapabilities.canApplyTypeInMethod) projectWithLookups = - addLookupsForImplementedGenerators[Class[Finalized.FinalTypes]]( - factory.convert(projectWithLookups), - { case (project, lookup) => factory.convert(project).addTypeLookupsForClasses(lookup) } + addLookupsForImplementedGenerators[ast.oo.Class]( + ast.factory.convert(projectWithLookups), + { case (project, lookup) => ast.factory.convert(project).addTypeLookupsForClasses(lookup) } )(ooParadigm.classCapabilities.canTranslateTypeInClass, generics.classCapabilities.canApplyTypeInClass) projectWithLookups = - addLookupsForImplementedGenerators[Constructor[Finalized.FinalTypes]]( - factory.convert(projectWithLookups), - { case (project, lookup) => factory.convert(project).addTypeLookupsForConstructors(lookup) } + addLookupsForImplementedGenerators[ast.oo.Constructor]( + ast.factory.convert(projectWithLookups), + { case (project, lookup) => ast.factory.convert(project).addTypeLookupsForConstructors(lookup) } )(ooParadigm.constructorCapabilities.canTranslateTypeInConstructor, generics.constructorCapabilities.canApplyTypeInConstructor) projectWithLookups = - addLookupsForImplementedGenerators[AlgebraicDataType[Finalized.FinalTypes]]( - factory.convert(projectWithLookups), - { case (project, lookup) => factory.convert(project).addTypeLookupsForAlgebraicDataTypes(lookup) } + addLookupsForImplementedGenerators[ast.functional.AlgebraicDataType]( + ast.factory.convert(projectWithLookups), + { case (project, lookup) => ast.factory.convert(project).addTypeLookupsForAlgebraicDataTypes(lookup) } )(functional.typeCapabilities.canTranslateTypeInType, parametricPolymorphismInADTContexts.algebraicDataTypeCapabilities.canApplyTypeInADT) val (generatedProject, _) = Command.runGenerator(generator, projectWithLookups) - val withPrefix = factory.convert(generatedProject).prefixRootPackage(Seq(nameProvider.mangle(domainName)), prefixExcludedTypes) + val withPrefix = ast.factory.convert(generatedProject).prefixRootPackage(Seq(nameProvider.mangle(domainName)), prefixExcludedTypes) - def toFileWithPath(cu: CompilationUnit[Finalized.FinalTypes], basePath: Path): FileWithPath = { - FileWithPath(factory.convert(cu).toScala, { - val nameAsStrings = cu.name.map(name => factory.convert(name).toScala) + def toFileWithPath(cu: ast.any.CompilationUnit, basePath: Path): FileWithPath = { + FileWithPath(ast.factory.convert(cu).toScala, { + val nameAsStrings = cu.name.map(name => ast.factory.convert(name).toScala) val nameWithScalaExtension = nameAsStrings.init :+ (nameAsStrings.last + ".scala") nameWithScalaExtension.foldLeft(basePath)({ case (path, name) => Paths.get(path.toString, name) @@ -184,7 +187,7 @@ sealed class CodeGenerator(domainName: String) { cc => val mainDir = Paths.get("src", "main", "scala") val testDir = Paths.get("src", "test", "scala") withPrefix.compilationUnits.flatMap(cu => { - import factory._ + import ast.factory.* val testFile = if (cu.tests.nonEmpty) { val testOnlyCu = cu.copyAsCompilationUnitWithClasses( classes = Seq.empty @@ -199,31 +202,31 @@ sealed class CodeGenerator(domainName: String) { cc => } else Seq.empty nonTestFile ++ testFile - }).toSeq :+ treeLibrary :+ buildFile :+ pluginsFile :+ scalaFmt + }).toSeq ++ withPrefix.customFiles :+ buildFile :+ pluginsFile :+ scalaFmt } - val paradigm = AnyParadigm[Finalized.FinalTypes, factory.type, syntax.type](factory, runGenerator, syntax) - val ooParadigm = OOParadigm[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) - val imperative = Imperative[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) - val functional = FunctionalParadigm[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) - val functionalControl = control.Functional[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) + val paradigm: WithSyntax[ast.type, syntax.type] = AnyParadigm[ast.type, syntax.type](ast, runGenerator, syntax) + val ooParadigm: OOParadigm.WithBase[ast.type, paradigm.type] = OOParadigm[ast.type, paradigm.type](paradigm) + val imperative: Imperative.WithBase[ast.type, paradigm.type] = Imperative[ast.type, paradigm.type](paradigm) + val functional: FunctionalParadigm.WithBase[ast.type, paradigm.type] = FunctionalParadigm[ast.type, paradigm.type](paradigm) + val functionalControl: WithBase[ast.type, paradigm.type] = control.Functional[ast.type, paradigm.type](paradigm) - val parametricPolymorphism = ParametricPolymorphism[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) - val generics = Generics[Finalized.FinalTypes, factory.type, paradigm.type](paradigm)(ooParadigm, parametricPolymorphism) - val parametricPolymorphismInADTContexts = ParametricPolymorphismInADTContexts[Finalized.FinalTypes, factory.type, paradigm.type](paradigm)(functional) + val parametricPolymorphism: ParametricPolymorphism.WithBase[ast.type, paradigm.type] = ParametricPolymorphism[ast.type, paradigm.type](paradigm) + val generics: Generics.WithBase[ast.type, paradigm.type, ooParadigm.type, parametricPolymorphism.type] = Generics[ast.type, paradigm.type, ooParadigm.type, parametricPolymorphism.type](paradigm, ooParadigm, parametricPolymorphism) + val parametricPolymorphismInADTContexts: ParametricPolymorphismInADTContexts.WithBase[ast.type, paradigm.type, functional.type] = ParametricPolymorphismInADTContexts[ast.type, paradigm.type, functional.type](paradigm, functional) - val booleans = Booleans[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) + val booleans: Booleans.WithBase[ast.type, paradigm.type] = Booleans[ast.type, paradigm.type](paradigm) - val doubles = Arithmetic[Finalized.FinalTypes, factory.type, paradigm.type, Double](paradigm) + val doubles: Arithmetic.WithBase[Double, ast.type, paradigm.type] = Arithmetic[Double, ast.type, paradigm.type](paradigm) - val realDoubles = RealArithmetic[Finalized.FinalTypes, factory.type, paradigm.type, Double](paradigm) + val realDoubles: RealArithmetic.WithBase[Double, ast.type, paradigm.type] = RealArithmetic[Double, ast.type, paradigm.type](paradigm) - val ints = Arithmetic[Finalized.FinalTypes, factory.type, paradigm.type, Int](paradigm) + val ints: Arithmetic.WithBase[Int, ast.type, paradigm.type] = Arithmetic[Int, ast.type, paradigm.type](paradigm) - val strings = Strings[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) + val strings: Strings.WithBase[ast.type, paradigm.type] = Strings[ast.type, paradigm.type](paradigm) - val equality = Equals[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) + val equality: Equals.WithBase[ast.type, paradigm.type] = Equals[ast.type, paradigm.type](paradigm) /*val consoleInMethod = new Console[MethodBodyCtxt, paradigm.type]( @@ -246,7 +249,7 @@ sealed class CodeGenerator(domainName: String) { cc => ) */ - val listsInMethod = Lists[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) + val lists: Lists.WithBase[ast.type, paradigm.type] = Lists[ast.type, paradigm.type](paradigm) /*val listsInConstructor = Lists[CtorCtxt, paradigm.type, generics.type]( @@ -257,8 +260,7 @@ sealed class CodeGenerator(domainName: String) { cc => ooParadigm.constructorCapabilities.canAddImportInConstructor )(generics) */ - val treesInMethod = - Trees[Finalized.FinalTypes, factory.type, paradigm.type](paradigm)(Map.empty) + /* val treesInConstructor = Trees[CtorCtxt, paradigm.type, ObjectOriented]( @@ -269,14 +271,8 @@ sealed class CodeGenerator(domainName: String) { cc => val assertionsInMethod = new Assertions[paradigm.type](paradigm)(ooParadigm) val exceptionsInMethod = new Exceptions[paradigm.type](paradigm)*/ - val assertionsInMethod = Assertions[Finalized.FinalTypes, factory.type, paradigm.type](paradigm) - - def treeLibrary: FileWithPath = { - FileWithPath( - getClass.getResourceAsStream("/scala-code/org/combinators/ep/util/Trees.scala").readAllBytes(), - Paths.get("src", "main", "scala", "org", "combinators", "ep", "util", "Trees.scala") - ) - } + val assertions = Assertions[ast.type, paradigm.type](paradigm) + } object CodeGenerator { @@ -286,6 +282,6 @@ object CodeGenerator { } - def apply(domainName: String): CodeGenerator = - new CodeGenerator(domainName) + def apply[AST <: FullAST](domainName: String, ast: AST, additionalPrefixExcludedTypes: Set[Seq[ast.any.Name]] = Set.empty): CodeGenerator[ast.type] = + new CodeGenerator[ast.type](domainName, ast, additionalPrefixExcludedTypes) } diff --git a/language/newScala/src/main/scala/org/combinators/ep/language/scala/package.scala b/language/newScala/src/main/scala/org/combinators/ep/language/scala/package.scala deleted file mode 100644 index 4314400b..00000000 --- a/language/newScala/src/main/scala/org/combinators/ep/language/scala/package.scala +++ /dev/null @@ -1,2224 +0,0 @@ -package org.combinators.ep.language /*DI:LD:AI*/ - -import org.combinators.ep.domain.abstractions.TypeRep -import org.combinators.ep.domain.abstractions.TypeRep.OfHostType -import org.combinators.ep.generator.Command.Generator -import org.combinators.ep.generator.NameProvider -import org.combinators.ep.language.inbetween.any -import org.combinators.ep.language.inbetween.oo -import org.combinators.ep.language.inbetween.imperative -import org.combinators.ep.language.inbetween.functional -import org.combinators.ep.language.inbetween.ffi.ArithmeticOps -import org.combinators.ep.language.inbetween.ffi.RealArithmeticOps -import org.combinators.ep.language.inbetween.ffi.AssertionOps -import org.combinators.ep.language.inbetween.ffi.BooleanOps -import org.combinators.ep.language.inbetween.ffi.EqualsOps -import org.combinators.ep.language.inbetween.ffi.OperatorExpressionOps -import org.combinators.ep.language.inbetween.ffi.StringOps -import org.combinators.ep.language.inbetween.ffi.ListOps -import org.combinators.ep.language.inbetween.ffi.TreeOps -import org.combinators.ep.language.inbetween.polymorphism.generics -import org.combinators.ep.language.inbetween.polymorphism -import org.combinators.ep.language.inbetween.oo.{Class, Constructor} - -import java.util.UUID - -package object scala { - trait FinalTypes - extends any.FinalTypes - with oo.FinalTypes - with imperative.FinalTypes - with OperatorExpressionOps.FinalTypes - with ListOps.FinalTypes - with TreeOps.FinalTypes - with generics.FinalTypes - with functional.FinalTypes - with functional.control.FinalTypes { - type ReifiedScalaValue[T] <: Expression - type BlockExpression <: Expression - type MethodReferenceExpression <: Expression - } - - trait Project[FT <: FinalTypes] extends oo.Project[FT] with functional.Project[FT] with Factory[FT] { - override def addTypeLookupsForMethods(lookups: TypeRep => Option[Generator[any.Method[FT], any.Type[FT]]]): any.Project[FT] = { - super.addTypeLookupsForMethods(lookups).addTypeLookupsForFunctions(lookups) - } - - def copyAsScalaProject( - compilationUnits: Set[any.CompilationUnit[FT]] = this.compilationUnits, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = this.classTypeLookupMap, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = this.adtTypeLookupMap, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.functionTypeLookupMap, - ): Project[FT] = scalaProject( - compilationUnits, - methodTypeLookupMap, - constructorTypeLookupMap, - classTypeLookupMap, - adtTypeLookupMap, - functionTypeLookupMap - ) - - override def copyAsProjectWithTypeLookups( - compilationUnits: Set[any.CompilationUnit[FT]] = this.compilationUnits, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = this.classTypeLookupMap - ): Project[FT] = - copyAsScalaProject( - compilationUnits = compilationUnits, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - classTypeLookupMap = classTypeLookupMap - ) - - override def copyAsFunctionalProject( - compilationUnits: Set[any.CompilationUnit[FT]] = this.compilationUnits, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = this.adtTypeLookupMap, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.functionTypeLookupMap, - ): Project[FT] = - copyAsScalaProject( - compilationUnits = compilationUnits, - adtTypeLookupMap = adtTypeLookupMap, - functionTypeLookupMap = functionTypeLookupMap, - ) - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Project[FT] = - copyAsScalaProject( - compilationUnits = compilationUnits.map(cu => convert(cu).prefixRootPackage(rootPackageName, excludedTypeNames)), - methodTypeLookupMap = tpeRep => methodTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - classTypeLookupMap = tpeRep => classTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - adtTypeLookupMap = tpeRep => adtTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - functionTypeLookupMap = tpeRep => functionTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - ) - } - - trait Import[FT <: FinalTypes] extends any.Import[FT] with Factory[FT] { - def components: Seq[any.Name[FT]] - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Import[FT] = { - if (excludedTypeNames.contains(components)) { - this - } else { - copy(components = rootPackageName ++ components) - } - } - - def toScala: String = - s"""import ${components.map(_.toScala).mkString(".")}""" - - def copy(components: Seq[any.Name[FT]] = this.components): any.Import[FT] = - importStatement(components) - } - - trait ScalaNode { - def toScala: String - } - - trait Statement[FT <: FinalTypes] extends any.Statement[FT] with Factory[FT] { - def toScala: String - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Statement[FT] - } - - trait DeclareVariable[FT <: FinalTypes] extends imperative.DeclareVariable[FT] with Statement[FT] with Factory[FT] { - def toScala: String = { - val init = this.initializer.map(ie => s" = ${ie.toScala}").getOrElse("") - s""" - |var ${this.name.toScala}: ${this.tpe.toScala}$init - |""".stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): imperative.DeclareVariable[FT] = { - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - initializer = initializer.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - } - - trait DeclareFunVariable[FT <: FinalTypes] extends functional.control.DeclareFunVariable[FT] with Expression[FT] with Factory[FT] { - def toScala: String = { - val decl = if (this.isRecursive) "def" else "val" - val body = this.inExp.toScala - s""" - |{ $decl ${this.name.toScala}: ${this.tpe.toScala} = ${this.initializer.toScala} - | $body } - |""".stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): DeclareFunVariable[FT] = { - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - initializer = initializer.prefixRootPackage(rootPackageName, excludedTypeNames), - inExp = inExp.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - } - - trait AssignVariable[FT <: FinalTypes] extends imperative.AssignVariable[FT] with Statement[FT] with Factory[FT] { - def toScala: String = { - s""" - |${this.variable.toScala} = ${this.assignmentExpression.toScala} - |""".stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): imperative.AssignVariable[FT] = - copy(assignmentExpression = assignmentExpression.prefixRootPackage(rootPackageName, excludedTypeNames)) - } - - trait IfThenElse[FT <: FinalTypes] extends imperative.IfThenElse[FT] with Statement[FT] with Factory[FT] { - def toScala: String = { - val elseIfs = elseIfBranches.map{ case (condition, body) => - s""" - |else if (${condition.toScala}) { - | ${body.map(_.toScala).mkString("\n ")} - |}""".stripMargin - } - - s""" - |if (${condition.toScala}) { - | ${this.ifBranch.map(_.toScala).mkString("\n ")} - |}${elseIfs.mkString("")} else { - | ${elseBranch.map(_.toScala).mkString("\n ")} - |} - """.stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): imperative.IfThenElse[FT] = - copy( - condition = condition.prefixRootPackage(rootPackageName, excludedTypeNames), - ifBranch = ifBranch.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - elseIfBranches = elseIfBranches.map { case (cond, branch) => - (cond.prefixRootPackage(rootPackageName, excludedTypeNames), - branch.map(_.prefixRootPackage(rootPackageName, excludedTypeNames))) - }, - elseBranch = elseBranch.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - ) - } - - trait FunIfThenElse[FT <: FinalTypes] extends functional.control.IfThenElse[FT] with Expression[FT] with Factory[FT] { - def toScala: String = { - val elseIfs = elseIfBranches.map{ case (condition, body) => - s""" - | else if (${condition.toScala}) { - | ${body.toScala} - |}""".stripMargin - } - - s""" - |if (${condition.toScala}) { - | ${this.ifBranch.toScala} - |}${elseIfs.mkString("")} else { - | ${elseBranch.toScala} - |} - """.stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.control.IfThenElse[FT] = - copy( - condition = condition.prefixRootPackage(rootPackageName, excludedTypeNames), - ifBranch = ifBranch.prefixRootPackage(rootPackageName, excludedTypeNames), - elseIfBranches = elseIfBranches.map { case (cond, branch) => - (cond.prefixRootPackage(rootPackageName, excludedTypeNames), - branch.prefixRootPackage(rootPackageName, excludedTypeNames)) - }, - elseBranch = elseBranch.prefixRootPackage(rootPackageName, excludedTypeNames), - ) - } - - trait While[FT <: FinalTypes] extends imperative.While[FT] with Statement[FT] with Factory[FT] { - def toScala: String = { - s""" - |while (${condition.toScala}) { - | ${body.map(_.toScala).mkString("\n ")} - |}""".stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): imperative.While[FT] = - copy( - condition = condition.prefixRootPackage(rootPackageName, excludedTypeNames), - body = body.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - - trait Expression[FT <: FinalTypes] extends oo.Expression[FT] with Factory[FT] { - def toScala: String - - def isTypeReferenceExpression: Boolean = false - - def toImport: Seq[any.Import[FT]] = Seq.empty - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Expression[FT] - } - - trait ReifiedScalaValue[FT <: FinalTypes, T] extends Expression[FT] with Factory[FT] { - def getSelfAsReifiedScalaValue: finalTypes.ReifiedScalaValue[T] - val ofHostType: OfHostType[T] - val value: T - - def toScala: String = { - ofHostType match { - case t: TypeRep.String.type => s""""$value"""" - case t: TypeRep.Tree.type => - value match { - case org.combinators.ep.domain.tree.Node(id, values) => s"org.combinators.ep.util.Node($id, ${values.map(v => reifiedScalaValue(TypeRep.Tree, v).toScala).mkString(", ")})" - case org.combinators.ep.domain.tree.Leaf(r) => s"org.combinators.ep.util.Leaf(${reifiedScalaValue(r.tpe, r.inst).toScala})" - } - case t: TypeRep.Sequence[_] => - value.asInstanceOf[Seq[t.elemTpe.HostType]].map(v => reifiedScalaValue(t.elemTpe, v).toScala).mkString("Seq(", ", ", ")") - case t: TypeRep.Array[_] => - value.asInstanceOf[Array[t.elemTpe.HostType]].map(v => reifiedScalaValue(t.elemTpe, v).toScala).mkString("Array(", ", ", ")") - case _ => - value.toString - } - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): ReifiedScalaValue[FT, T] = - this - } - - trait ArgumentExpression[FT <: FinalTypes] extends Expression[FT] with any.ArgumentExpression[FT] with Factory[FT] { - def toScala: String = s"${parameterName.toScala}" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.ArgumentExpression[FT] = - this - } - - trait MemberAccessExpression[FT <: FinalTypes] extends Expression[FT] with oo.MemberAccessExpression[FT] with Factory[FT] { - def toScala: String = s"${owner.toScala}.${field.toScala}" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.MemberAccessExpression[FT] = - copy(owner = owner.prefixRootPackage(rootPackageName, excludedTypeNames)) - } - - trait SelfReferenceExpression[FT <: FinalTypes] extends Expression[FT] with oo.SelfReferenceExpression[FT] with Factory[FT] { - def toScala: String = s"this" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.SelfReferenceExpression[FT] = - this - } - - trait ObjectInstantiationExpression[FT <: FinalTypes] extends Expression[FT] with oo.ObjectInstantiationExpression[FT] with Factory[FT] { - def toScala: String = { - val bodyScala = body.map(_.classBodyDefinitionToScala).getOrElse("") - s"""new ${tpe.toScala}(${constructorArguments.map(_.toScala).mkString(",")})$bodyScala""" - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.ObjectInstantiationExpression[FT] = - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - constructorArguments = constructorArguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - body = body.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - - trait CastExpression[FT <: FinalTypes] extends Expression[FT] with oo.CastExpression[FT] with Factory[FT] { - def toScala: String = s"${this.expression.toScala}.asInstanceOf[${tpe.toScala}]" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.CastExpression[FT] = - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait InstanceOfExpression[FT <: FinalTypes] extends Expression[FT] with oo.InstanceOfExpression[FT] with Factory[FT] { - def toScala: String = { - s"${this.expression.toScala}.isInstanceOf[${this.tpe.toScala}]" - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.InstanceOfExpression[FT] = - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait SuperReferenceExpression[FT <: FinalTypes] extends Expression[FT] with oo.SuperReferenceExpression[FT] with Factory[FT] { - def toScala: String = { - s"super[${parentType.toScala}]" - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.SuperReferenceExpression[FT] = - copy( - parentType = parentType.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait BinaryExpression[FT <: FinalTypes] extends Expression[FT] with OperatorExpressionOps.BinaryExpression[FT] with Factory[FT] { - def toScala: String = s"(${operator.toScala(left, right)})" // necessary when composing expressions, though can get excessive at times. - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): OperatorExpressionOps.BinaryExpression[FT] = - copy( - left = left.prefixRootPackage(rootPackageName, excludedTypeNames), - right = right.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait UnaryExpression[FT <: FinalTypes] extends Expression[FT] with OperatorExpressionOps.UnaryExpression[FT] with Factory[FT] { - def toScala: String = operator.toScala(operand) - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): OperatorExpressionOps.UnaryExpression[FT] = - copy( - operand = operand.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait Operator[FT <: FinalTypes] extends OperatorExpressionOps.Operator[FT] with Factory[FT] { - def toScala(operands: any.Expression[FT]*): String - } - - trait InfixOperator[FT <: FinalTypes] { self: Factory[FT] => - def operator: String - def toScala(operands: any.Expression[FT]*): String = operands.map(_.toScala).mkString(operator) - } - - trait PrefixOperator[FT <: FinalTypes] { self: Factory[FT] => - def operator: String - def toScala(operands: any.Expression[FT]*): String = s"($operator${operands.head.toScala})" - } - - trait MathFunctionOperator[FT <: FinalTypes] { self: Factory[FT] => - def operator: String - def toScala(operands: any.Expression[FT]*): String = { - s"Math.$operator${operands.map(_.toScala).mkString("(", ", ", ")")}" - } - } - - trait PostfixOperator[FT <: FinalTypes] { self: Factory[FT] => - def operator: String - def toScala(operands: any.Expression[FT]*): String = s"(${operands.head.toScala}$operator)" - } - - trait AddOp[FT <: FinalTypes] extends ArithmeticOps.AddOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "+" - } - - trait SubOp[FT <: FinalTypes] extends ArithmeticOps.SubOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "-" - } - - trait MultOp[FT <: FinalTypes] extends ArithmeticOps.MultOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "*" - } - - trait DivOp[FT <: FinalTypes] extends ArithmeticOps.DivOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "/" - } - - trait ModOp[FT <: FinalTypes] extends ArithmeticOps.ModOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "%" - } - - trait LtOp[FT <: FinalTypes] extends ArithmeticOps.LtOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "<" - } - - trait LeOp[FT <: FinalTypes] extends ArithmeticOps.LeOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "<=" - } - - trait AndOp[FT <: FinalTypes] extends BooleanOps.AndOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "&&" - } - - trait OrOp[FT <: FinalTypes] extends BooleanOps.OrOp[FT] with Operator[FT] with Factory[FT] with InfixOperator[FT] { - override def operator: String = "||" - } - - trait NotOp[FT <: FinalTypes] extends BooleanOps.NotOp[FT] with Operator[FT] with Factory[FT] with PrefixOperator[FT] { - override def operator: String = "!" - } - - trait SqrtOp[FT <: FinalTypes] extends RealArithmeticOps.SqrtOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "sqrt" - } - - trait PowOp[FT <: FinalTypes] extends RealArithmeticOps.PowOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "pow" - } - - trait LogOp[FT <: FinalTypes] extends RealArithmeticOps.LogOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "log" - - override def toScala(operands: any.Expression[FT]*): String = { - s"(Math.$operator(${operands(0).toScala})/Math.$operator(${operands(1).toScala}))" - } - } - - trait SinOp[FT <: FinalTypes] extends RealArithmeticOps.SinOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "sin" - } - - trait CosOp[FT <: FinalTypes] extends RealArithmeticOps.CosOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "cos" - } - - trait AbsOp[FT <: FinalTypes] extends RealArithmeticOps.AbsOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "abs" - } - - trait FloorOp[FT <: FinalTypes] extends RealArithmeticOps.FloorOp[FT] with Operator[FT] with Factory[FT] with MathFunctionOperator[FT] { - override def operator: String = "floor" - } - - trait EulersNumber[FT <: FinalTypes] extends RealArithmeticOps.EulersNumber[FT] with Expression[FT] with Factory[FT] { - override def toScala: String = "Math.E" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): RealArithmeticOps.EulersNumber[FT] = - this - } - - trait Pi[FT <: FinalTypes] extends RealArithmeticOps.Pi[FT] with Expression[FT] with Factory[FT] { - override def toScala: String = "Math.PI" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): RealArithmeticOps.Pi[FT] = - this - } - - - trait True[FT <: FinalTypes] extends BooleanOps.True[FT] with Expression[FT] with Factory[FT] { - override def toScala: String = "true" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): BooleanOps.True[FT] = - this - } - - trait False[FT <: FinalTypes] extends BooleanOps.False[FT] with Expression[FT] with Factory[FT] { - override def toScala: String = "false" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): BooleanOps.False[FT] = - this - } - - trait Equals[FT <: FinalTypes] extends EqualsOps.Equals[FT] with Expression[FT] with Factory[FT] { - def toScala: String = s"${left.toScala} == ${right.toScala}" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): EqualsOps.Equals[FT] = - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - left = left.prefixRootPackage(rootPackageName, excludedTypeNames), - right = right.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait Return[FT <: FinalTypes] extends any.Return[FT] with Statement[FT] with Factory[FT] { - def toScala: String = s"return { ${this.expression.toScala.stripLeading()} }" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Return[FT] = - copy( - expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait LiftExpression[FT <: FinalTypes] extends imperative.LiftExpression[FT] with Statement[FT] with Factory[FT] { - def toScala: String = s"${this.expression.toScala};" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): imperative.LiftExpression[FT] = - copy( - expression = expression.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait Type[FT <: FinalTypes] extends any.Type[FT] with Factory[FT] { - def toScala: String - def toImport: Seq[any.Import[FT]] - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Type[FT] - } - - trait ClassReferenceType[FT <: FinalTypes] extends oo.ClassReferenceType[FT] with Type[FT] with Factory[FT] { - def toScala: String = qualifiedClassName.map(_.toScala).mkString(".") - - def toImport: Seq[any.Import[FT]] = Seq.empty - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.ClassReferenceType[FT] = { - if (excludedTypeNames.contains(qualifiedClassName)) { - this - } else { - copy( - qualifiedClassName = rootPackageName ++ qualifiedClassName - ) - } - } - } - - trait ADTReferenceType[FT <: FinalTypes] extends functional.ADTReferenceType[FT] with Type[FT] with Factory[FT] { - def toScala: String = qualifiedTypeName.map(_.toScala).mkString(".") - - def toImport: Seq[any.Import[FT]] = Seq.empty - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.ADTReferenceType[FT] = { - if (excludedTypeNames.contains(qualifiedTypeName)) { - this - } else { - copy( - qualifiedTypeName = rootPackageName ++ qualifiedTypeName - ) - } - } - } - - trait Name[FT <: FinalTypes] extends any.Name[FT] with Factory[FT] { - def component: String - def mangled: String - def toScala: String = mangled - } - - trait Util[FT <: FinalTypes] extends Factory[FT] { - def nameProvider: NameProvider[any.Name[FT]] - def reify[T](tpe: OfHostType[T], value: T): any.Expression[FT] = reifiedScalaValue(tpe, value) - - def findType(name: Seq[any.Name[FT]]): any.Type[FT] = adtReferenceType(name: _*) - - def resolveImport(tpe: any.Type[FT]): Seq[any.Import[FT]] = tpe.toImport - def resolveImport(expr: any.Expression[FT]): Seq[any.Import[FT]] = expr.toImport - def getFreshName(basedOn: any.Name[FT]): any.Name[FT] = { - val id = UUID.randomUUID().toString.replace("-", "") - nameProvider.mangle(s"${basedOn.component}_$id") - } - } - - trait Method[FT <: FinalTypes] extends generics.Method[FT] with functional.Method[FT] with functional.control.Method[FT] with Factory[FT] with Util[FT] { - override def emptyPatternCtxt: functional.control.PatternContext[FT] = patternContext(Seq.empty) - - def addTestExpressions(exprs: Seq[any.Expression[FT]]): any.Method[FT] = { - copy(statements = exprs.map(liftExpression)) - } - - def findClass(qualifiedName: any.Name[FT]*): any.Type[FT] = - classReferenceType(qualifiedName:_*) - - def findMethod(qualifiedName: Seq[any.Name[FT]]): any.Expression[FT] = - methodReferenceExpression(qualifiedName) - - def toScala: String = { - val overrideMod = if (isOverride) "override" else "" - val privateMod = if (!isPublic) "private" else "" - val mods = Seq(overrideMod, privateMod).mkString(" ") - - val params = parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString(",") - val typeParams = if (typeParameters.isEmpty) "" else typeParameters.map(_.toScala).mkString("[", ",", "]") - val returnTpe = returnType.map(_.toScala).getOrElse("Unit") - val body = if (!isAbstract) { - s"""= { - | ${imports.map(_.toScala).mkString("\n ")} - | ${statements.map(_.toScala).mkString("\n ")} - |} - """.stripMargin - } else "" - - s"""$mods def ${name.toScala}$typeParams($params): $returnTpe $body""".stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Method[FT] = { - copyAsGenericMethod( - name = name, - imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - statements = statements.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - returnType = returnType.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - typeParameters = typeParameters.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - parameters = parameters.map { case (name, tpe) => (name, tpe.prefixRootPackage(rootPackageName, excludedTypeNames)) }, - typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - } - - trait Lambda[FT <: FinalTypes] extends functional.control.Lambda[FT] with Expression[FT] with Factory[FT] { - def toScala: String = { - val vars = this.variables.map { case (v, tpe) => s"${v.toScala}: ${tpe.toScala}" }.mkString("(", ", ", ")") - val body = this.body.toScala - s"$vars => {\n $body \n}" - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.Expression[FT] = - copy( - variables = this.variables.map { case (v, tpe) => (v, tpe.prefixRootPackage(rootPackageName, excludedTypeNames)) }, - body = this.body.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - - trait Constructor[FT <: FinalTypes] extends oo.Constructor[FT] with scala.Method[FT] with Factory[FT] { - - override def typeParameters: Seq[polymorphism.TypeParameter[FT]] = Seq.empty - override def name: any.Name[FT] = nameProvider.mangle(constructedType.map(_.toScala).getOrElse("")) - override def returnType: Option[any.Type[FT]] = constructedType - - def importDecls: String = imports.map(_.toScala).mkString("\n ") - - override def toScala: String = { - val params = parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString(",") - val superInitDecls = if (superInitialization.isDefined) { - s"// Potential Generator Defect: Scala cannot declare supers in secondary constructor" - } else "" - val fieldInitDecls = fieldInitializers.map(fi =>{ - s"${fi._2.toScala}" - }).mkString(", ") - val bodyDecls = - s""" - | ${statements.map(_.toScala).mkString("\n ")} - """.stripMargin - - s"""def this($params) = { - | this($fieldInitDecls) - | $importDecls - | $bodyDecls - |}""".stripMargin - } - - def primaryConstructorParams: String = { - parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString("(", ",", ")") - } - - def parentInitializers(ofClass: oo.Class[FT]): String = { - val supers = (ofClass.parents ++ ofClass.implemented).distinct - superInitialization match { - case Some((parent, parentArgs)) => - val rest = supers.filter(sp => sp != parent).map(_.toScala) - val withRest = if (rest.isEmpty) "" else rest.mkString("with ", " with ", "") - s"extends ${parent.toScala}(${parentArgs.map(_.toScala).mkString(", ")}) $withRest" - case None => - if (supers.nonEmpty) supers.map(_.toScala).mkString("extends ", " with ", "") else "" - } - } - - def primaryConstructorBody(ofClass: oo.Class[FT]): String = { - val (fieldDeclarations, remainingPrimaryInits) = { - ofClass.fields.foldLeft[(Seq[String], Seq[(any.Name[FT], any.Expression[FT])])]((Seq.empty, fieldInitializers)) { - case ((decls, remainingInitializers), declaredField) => { - if (declaredField.init.isDefined) { - (decls :+ convert(declaredField).toScala, remainingInitializers) - } else { - def extractFirstDeclaration(decls: Seq[(any.Name[FT], any.Expression[FT])]): (Seq[(any.Name[FT], any.Expression[FT])], Option[any.Expression[FT]]) = - decls match { - case (name, init) +: rest if name == declaredField.name => - (rest, Some(init)) - case hd +: rest => - val (remaining, init) = extractFirstDeclaration(rest) - (hd +: remaining, init) - case _ => (Seq.empty, None) - } - val (remaining, init) = extractFirstDeclaration(remainingInitializers) - (decls :+ convert(declaredField.copy(init = init)).toScala, remaining) - } - } - } - } - val overrideInits = remainingPrimaryInits.map(fi => { - s"this.${fi._1.toScala} = ${fi._2.toScala}" - }).mkString(" \n") - val bodyDecls = - s""" - | ${statements.map(_.toScala).mkString("\n ")} - """.stripMargin - s""" - | $importDecls - | ${fieldDeclarations.mkString("\n ")} - | $overrideInits - | $bodyDecls - | """.stripMargin - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.Constructor[FT] = { - copyAsConstructor( - constructedType = constructedType.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - statements = statements.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - parameters = parameters.map { case (name, tpe) => (name, tpe.prefixRootPackage(rootPackageName, excludedTypeNames)) }, - typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - superInitialization = superInitialization.map { case (tpe, exps) => - (tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - exps.map(_.prefixRootPackage(rootPackageName, excludedTypeNames))) - }, - fieldInitializers = fieldInitializers.map { case (name, exp) => (name, exp.prefixRootPackage(rootPackageName, excludedTypeNames)) } - ) - } - } - - trait Field[FT <: FinalTypes] extends oo.Field[FT] with Factory[FT] { - def toScala: String = { - val initExp = init.map(exp => s" = ${exp.toScala}").getOrElse(s" = null.asInstanceOf[${tpe.toScala}]") - s"var ${name.toScala}: ${tpe.toScala}$initExp" - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.Field[FT] = { - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - init = init.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - ) - } - - } - - trait TypeParameter[FT <: FinalTypes] extends generics.TypeParameter[FT] with Factory[FT] { - def toScala: String = { - val lbs = - if (lowerBounds.nonEmpty) " <: " + lowerBounds.map(_.toScala).mkString(" with ") else "" - val ubs = - if (upperBounds.nonEmpty) " >: " + upperBounds.map(_.toScala).mkString(" with ") else "" - s"""${name.toScala}$lbs$ubs""" - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): polymorphism.TypeParameter[FT] = { - copyAsTypeParameterWithBounds( - upperBounds = upperBounds.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - lowerBounds = lowerBounds.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - ) - } - } - - trait TypeReferenceExpression[FT <: FinalTypes] extends polymorphism.TypeReferenceExpression[FT] with Expression[FT] with Factory[FT] { - def toScala: String = tpe.toScala - - override def isTypeReferenceExpression: Boolean = true - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): polymorphism.TypeReferenceExpression[FT] = { - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames) - ) - } - } - - trait MethodReferenceExpression[FT <: FinalTypes] extends Expression[FT] with Factory[FT] { - def getSelfAsMethodReferenceExpression: finalTypes.MethodReferenceExpression - - def qualifiedMethodName: Seq[any.Name[FT]] - - def toScala: String = qualifiedMethodName.map(_.toScala).mkString(".") - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): MethodReferenceExpression[FT] = { - if (excludedTypeNames.contains(qualifiedMethodName)) { - this - } else { - copy( - qualifiedMethodName = rootPackageName ++ qualifiedMethodName - ) - } - } - - def copy(qualifiedMethodName: Seq[any.Name[FT]] = this.qualifiedMethodName): MethodReferenceExpression[FT] = methodReferenceExpression(qualifiedMethodName) - } - - - trait TypeArgument[FT <: FinalTypes] extends polymorphism.TypeArgument[FT] with Type[FT] with Factory[FT] { - def toScala: String = name.toScala - - def toImport: Seq[any.Import[FT]] = Seq.empty - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): polymorphism.TypeArgument[FT] = { - this - } - } - - trait TypeApplication[FT <: FinalTypes] extends polymorphism.TypeApplication[FT] with Type[FT] with Factory[FT] { - def toScala: String = { - s"${function.toScala}[${arguments.map(_.toScala).mkString(", ")}]" - } - - def toImport: Seq[any.Import[FT]] = function.toImport ++ arguments.flatMap(_.toImport) - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): polymorphism.TypeApplication[FT] = { - copy( - function = function.prefixRootPackage(rootPackageName, excludedTypeNames), - arguments = arguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - } - - - - trait Class[FT <: FinalTypes] extends generics.Class[FT] with Factory[FT] with Util[FT] { - - - def findClass(qualifiedName: any.Name[FT]*): any.Type[FT] = { - classReferenceType(qualifiedName: _*) - } - - def classBodyDefinitionToScala: String = { - val importDecls = imports.map(_.toScala).mkString("\n ") - val fieldDecls = fields.map(_.toScala).mkString("\n ") - val methodDecls = methods.map(_.toScala).mkString("\n ") - val secondaryConstructorDecls = if (constructors.isEmpty) "" else constructors.tail.map(_.toScala).mkString("\n ") - val initBlock = constructors.headOption.map(ctor => - convert(ctor).primaryConstructorBody(this) - ).getOrElse(fieldDecls) - s""" - |{ - | $importDecls - | $initBlock - | $secondaryConstructorDecls - | $methodDecls - |}""".stripMargin - } - - def toScala: String = { - val kind = if (isInterface) "trait" else if (isStatic) "object" else "class" - val abstractMod = if (isAbstract && !isInterface) "abstract" else "" - val typeParams = { - val ps = typeParameters.map(_.toScala) - if (!isStatic && ps.nonEmpty) ps.mkString("[", ",", "]") else "" - } - val extendsClause = constructors.headOption.map(ctor => - convert(ctor).parentInitializers(this) - ).getOrElse { - val supers = (parents ++ implemented).distinct - if (supers.nonEmpty) supers.map(_.toScala).mkString("extends ", " with ", "") else "" - } - val primaryConstructorParams = constructors.headOption.map(ctor => - convert(ctor).primaryConstructorParams - ).getOrElse("") - - - s""" - |$abstractMod $kind ${name.toScala}$typeParams$primaryConstructorParams $extendsClause $classBodyDefinitionToScala""".stripMargin - } - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): oo.Class[FT] = { - copyAsGenericClass( - imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - typeParameters = typeParameters.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - parents = parents.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - implemented = implemented.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - fields = fields.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - methods = methods.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - constructors = constructors.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - methodTypeLookupMap = tpeRep => methodTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - } - - trait TestSuite[FT <: FinalTypes] extends oo.TestSuite[FT] with Factory[FT] with Util[FT] { - def inFunSuiteStyle: oo.Class[FT] = { - val withFunSuiteExtension = - underlyingClass.addParent(classReferenceType( - Seq("org", "scalatest", "funsuite", "AnyFunSuite").map(n => nameProvider.mangle(n)): _* - )) - val methodsAsTests = withFunSuiteExtension.methods.zip(this.testMarkers).filter{case (m, isTest) => isTest}.map{case (m, _) => { - liftExpression(applyExpression( - applyExpression( - memberAccessExpression(selfReferenceExpression, nameProvider.mangle("test")), - Seq(reifiedScalaValue(TypeRep.String, m.name.component)) - ), - Seq(blockExpression(m.statements)) - )) - }} - val withPrimaryClsConstructor = if (underlyingClass.constructors.isEmpty) { - withFunSuiteExtension.addConstructor(constructor(statements = methodsAsTests)) - } else { - val updatedPrimary = underlyingClass.constructors.head.copyAsConstructor( - statements = underlyingClass.constructors.head.statements ++ methodsAsTests - ) - withFunSuiteExtension.copy(constructors = updatedPrimary +: underlyingClass.constructors.tail) - } - val helperMethods = withPrimaryClsConstructor.methods.zip(testMarkers).filter{case (_, isTest) => !isTest}.map(_._1) - - withPrimaryClsConstructor.copy(methods = helperMethods) - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.TestSuite[FT] = { - copyAsClassBasedTestSuite(underlyingClass = underlyingClass.prefixRootPackage(rootPackageName, excludedTypeNames)) - } - - def toScala: String = inFunSuiteStyle.toScala - } - - trait BlockExpression[FT <: FinalTypes] extends Expression[FT] with Factory[FT] { - def getSelfBlockExpression: finalTypes.BlockExpression - - def statements: Seq[any.Statement[FT]] = Seq.empty - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): BlockExpression[FT] = { - copy( - statements = statements.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - - def toScala: String = { - statements.map(_.toScala).mkString("{\n", "\n ", "}") - } - - def copy(statements: Seq[any.Statement[FT]] = this.statements): BlockExpression[FT] = - blockExpression(statements) - } - - trait ApplyExpression[FT <: FinalTypes] extends Expression[FT] with any.ApplyExpression[FT] with Factory[FT] { - def toScala : String = { - val (typeArguments, regularArguments) = arguments.partition(_.isTypeReferenceExpression) - - // If Type arguments, then emit those without the arguments, which appear to come later - if (typeArguments.nonEmpty) { - val tyArgs = typeArguments.map(_.toScala).mkString("[", ", ", "]") - s"${function.toScala}$tyArgs" - } else { - val args = if (regularArguments.isEmpty) "()" else regularArguments.map(_.toScala).mkString("(", ", ", ")") - s"${function.toScala}$args" - } - - //val result = s"${function.toScala}${tyArgs}${args}" - //result - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.ApplyExpression[FT] = { - copy( - function = function.prefixRootPackage(rootPackageName, excludedTypeNames), - arguments = arguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - } - - trait VariableReferenceExpression[FT <: FinalTypes] extends Expression[FT] with imperative.VariableReferenceExpression[FT] with Factory[FT] { - def toScala: String = s"${name.toScala}" - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): imperative.VariableReferenceExpression[FT] = - this - } - - trait CompilationUnit[FT <: FinalTypes] extends oo.CompilationUnit[FT] with functional.CompilationUnit[FT] with Factory[FT] with Util[FT] { - def toScala: String = { - val importDecls = imports.map(_.toScala).mkString("\n ") - val adtsDecl = adts.map(_.toScala).mkString("\n\n") - val clsDecls = classes.map(_.toScala).mkString("\n\n") - val testDecls = tests.map(_.toScala).mkString("\n\n") - val packageDecl = if (name.init.isEmpty) "" else s"package ${name.init.map(_.toScala).mkString(".")}" - val functionsDecl = functions.map(fun => { - fun.copyAsClsMethod(isPublic = true).toScala - }).mkString("\n\n") - - s""" - |$packageDecl - |$importDecls - |$adtsDecl - |$clsDecls - |$functionsDecl - |$testDecls - |""".stripMargin - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): any.CompilationUnit[FT] = { - copyAsScalaCompilationUnit( - name = rootPackageName ++ name, - imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - methodTypeLookupMap = tpeRep => methodTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - constructorTypeLookupMap = tpeRep => constructorTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - classTypeLookupMap = tpeRep => classTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - adtTypeLookupMap = tpeRep => adtTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - functionTypeLookupMap = tpeRep => functionTypeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - classes = classes.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - adts = adts.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - functions = functions.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - tests = tests.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - ) - } - - def copyAsScalaCompilationUnit( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = this.classTypeLookupMap, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = this.adtTypeLookupMap, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.functionTypeLookupMap, - classes: Seq[oo.Class[FT]] = this.classes, - adts: Seq[functional.AlgebraicDataType[FT]] = this.adts, - functions: Seq[any.Method[FT]] = this.functions, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): CompilationUnit[FT] = scalaCompilationUnit(name, imports, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap, adtTypeLookupMap, functionTypeLookupMap, classes, adts, functions, tests) - - override def copyAsCompilationUnitWithClasses( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.methodTypeLookupMap, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = this.constructorTypeLookupMap, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = this.classTypeLookupMap, - classes: Seq[oo.Class[FT]] = this.classes, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): CompilationUnit[FT] = - copyAsScalaCompilationUnit( - name = name, - imports = imports, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - classTypeLookupMap = classTypeLookupMap, - classes = classes, - tests = tests) - - override def copyAsFunctionalCompilationUnit( - name: Seq[any.Name[FT]] = this.name, - imports: Seq[any.Import[FT]] = this.imports, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = this.adtTypeLookupMap, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = this.functionTypeLookupMap, - adts: Seq[functional.AlgebraicDataType[FT]] = this.adts, - functions: Seq[any.Method[FT]] = this.functions, - tests: Seq[any.TestSuite[FT]] = this.tests, - ): CompilationUnit[FT] = copyAsScalaCompilationUnit( - name = name, - imports = imports, - adtTypeLookupMap = adtTypeLookupMap, - functionTypeLookupMap = functionTypeLookupMap, - adts = adts, - functions = functions, - tests = tests) - - override def initializeInProject(project: any.Project[FT]): any.CompilationUnit[FT] = { - val withLookups = copyAsScalaCompilationUnit( - adtTypeLookupMap = project.adtTypeLookupMap, - functionTypeLookupMap = project.functionTypeLookupMap, - methodTypeLookupMap = project.methodTypeLookupMap, - constructorTypeLookupMap = project.constructorTypeLookupMap, - classTypeLookupMap = project.classTypeLookupMap, - ) - withLookups.copyAsScalaCompilationUnit( - tests = withLookups.tests.map(_.initializeInCompilationUnit(withLookups)) - ) - } - - } - - trait AlgebraicDataType[FT <: FinalTypes] extends functional.AlgebraicDataType[FT] with Type[FT] with Factory[FT] with Util[FT] { - override def toImport: Seq[any.Import[FT]] = Seq.empty - - def toScala: String = { - val ctors = this.typeConstructors.map(_.toScala).mkString("\n ") - s""" - |enum ${this.name.toScala} { - | $ctors - |}""".stripMargin - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): AlgebraicDataType[FT] = - copy( - imports = imports.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - typeConstructors = typeConstructors.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - typeLookupMap = tpeRep => typeLookupMap(tpeRep).map(_.prefixRootPackage(rootPackageName, excludedTypeNames)), - ) - } - - trait TypeConstructor[FT <: FinalTypes] extends functional.TypeConstructor[FT] with Factory[FT] { - def toScala: String = { - val params = parameters.map(p => s"${p._1.toScala} : ${p._2.toScala}").mkString(",") - s"""case ${name.toScala}($params)""" - } - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.TypeConstructor[FT] = { - copy(parameters = this.parameters.map(p => (p._1, p._2.prefixRootPackage(rootPackageName, excludedTypeNames)))) - } - } - - trait TypeInstantiationExpression[FT <: FinalTypes] extends functional.TypeInstantiationExpression[FT] with Expression[FT] { - override def toScala: String = { - s"""${tpe.toScala}.${constructorName.map(_.toScala).mkString(".")}(${constructorArguments.map(_.toScala).mkString(", ")})""".stripMargin - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.TypeInstantiationExpression[FT] = - copy( - tpe = tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - constructorArguments = constructorArguments.map(_.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - - trait ToStringOp[FT <: FinalTypes] extends StringOps.ToStringOp[FT] with Operator[FT] with PostfixOperator[FT] { - def operator: String = ".toString()" - } - - trait AppendStringOp[FT <: FinalTypes] extends StringOps.AppendStringOp[FT] with Operator[FT] with InfixOperator[FT] { - def operator: String = "++" - } - trait StringLengthOp[FT <: FinalTypes] extends StringOps.StringLengthOp[FT] with Operator[FT] with PostfixOperator[FT] { - def operator: String = ".length" - } - trait AssertTrueOp[FT <: FinalTypes] extends AssertionOps.AssertTrueOp[FT] with Operator[FT] { - def operator: String = "assert " - def toScala(operands: any.Expression[FT]*): String = s"assert (${operands.head.toScala})" - } - - trait CreateList[FT <: FinalTypes] extends ListOps.CreateList[FT] with Type[FT] { - def toScala: String = "Seq" - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): ListOps.CreateList[FT] = - this - def toImport: Seq[any.Import[FT]] = Seq.empty - } - - trait CreateLeaf[FT <: FinalTypes] extends TreeOps.CreateLeaf[FT] with Type[FT] { - def leafClass: oo.ClassReferenceType[FT] - def toScala: String = leafClass.toScala - - def copyWithLeafClass(leafClass: oo.ClassReferenceType[FT] = leafClass): TreeOps.CreateLeaf[FT] = - createLeafWithLeafClass(leafClass) - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): TreeOps.CreateLeaf[FT] = - copyWithLeafClass(leafClass = leafClass.prefixRootPackage(rootPackageName, excludedTypeNames)) - - def toImport: Seq[any.Import[FT]] = leafClass.toImport - } - - trait CreateNodeExpr[FT <: FinalTypes] extends TreeOps.CreateNodeExpr[FT] with Expression[FT] { - def nodeClass: oo.ClassReferenceType[FT] - def toScala: String = nodeClass.toScala - - def copyWithNodeClass(nodeClass: oo.ClassReferenceType[FT] = nodeClass): TreeOps.CreateNodeExpr[FT] = - createNodeExprWithNodeClass(nodeClass) - - def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): TreeOps.CreateNodeExpr[FT] = - copyWithNodeClass(nodeClass = nodeClass.prefixRootPackage(rootPackageName, excludedTypeNames)) - } - - trait ConsListOp[FT <: FinalTypes] extends ListOps.ConsListOp[FT] with Operator[FT] with InfixOperator[FT] { - def operator: String = "+:" - } - - trait HeadListOp[FT <: FinalTypes] extends ListOps.HeadListOp[FT] with Operator[FT] with PostfixOperator[FT] { - def operator: String = ".head" - } - - trait TailListOp[FT <: FinalTypes] extends ListOps.TailListOp[FT] with Operator[FT] with PostfixOperator[FT] { - def operator: String = ".tail" - } - - trait AppendListOp[FT <: FinalTypes] extends ListOps.AppendListOp[FT] with Operator[FT] with InfixOperator[FT] { - def operator: String = "++" - } - - trait PatternContext[FT <: FinalTypes] extends functional.control.PatternContext[FT] with Factory[FT] with Util[FT] { - } - - trait PatternVariable[FT <: FinalTypes] extends functional.control.PatternVariable[FT] with Expression[FT] { - override def toScala: String = this.name.toScala - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.control.PatternVariable[FT] = this - } - - trait ConstructorPattern[FT <: FinalTypes] extends functional.control.ConstructorPattern[FT] with Expression[FT] { - override def toScala: String = { - s"""${tpe.toScala}.${constructor.toScala}(${arguments.map(_.toScala).mkString(", ")})""" - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.control.ConstructorPattern[FT] = { - copy( - tpe = this.tpe.prefixRootPackage(rootPackageName, excludedTypeNames), - arguments = this.arguments.map(arg => arg.prefixRootPackage(rootPackageName, excludedTypeNames)) - ) - } - } - - trait PatternMatch[FT <: FinalTypes] extends functional.control.PatternMatch[FT] with Expression[FT] { - override def toScala: String = { - val cases = this.cases.map { case (pat, body) => s"case ${pat.toScala} => { ${body.toScala} }" }.mkString("\n ") - s""" - |${onValue.toScala} match { - | $cases - |}""".stripMargin - } - - override def prefixRootPackage(rootPackageName: Seq[any.Name[FT]], excludedTypeNames: Set[Seq[any.Name[FT]]]): functional.control.PatternMatch[FT] = { - copy( - onValue = this.onValue.prefixRootPackage(rootPackageName, excludedTypeNames), - cases = this.cases.map{ case (pat, body) => (pat.prefixRootPackage(rootPackageName, excludedTypeNames), body.prefixRootPackage(rootPackageName, excludedTypeNames)) } - ) - } - } - - - trait Factory[FT <: FinalTypes] - extends any.Factory[FT] - with oo.Factory[FT] - with imperative.Factory[FT] - with functional.Factory[FT] - with functional.control.Factory[FT] - with ArithmeticOps.Factory[FT] - with RealArithmeticOps.Factory[FT] - with AssertionOps.Factory[FT] - with BooleanOps.Factory[FT] - with EqualsOps.Factory[FT] - with OperatorExpressionOps.Factory[FT] - with StringOps.Factory[FT] - with ListOps.Factory[FT] - with TreeOps.Factory[FT] - with generics.Factory[FT] { - - - override def ooProject( - compilationUnits: Set[any.CompilationUnit[FT]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = Map.empty, - ): oo.Project[FT] = scalaProject( - compilationUnits = compilationUnits, - adtTypeLookupMap = Map.empty, - functionTypeLookupMap = Map.empty, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - classTypeLookupMap = classTypeLookupMap, - ) - - override def functionalProject( - compilationUnits: Set[any.CompilationUnit[FT]], - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - ): functional.Project[FT] = scalaProject( - compilationUnits = compilationUnits, - adtTypeLookupMap = adtTypeLookupMap, - functionTypeLookupMap = functionTypeLookupMap, - methodTypeLookupMap = Map.empty, - constructorTypeLookupMap = Map.empty, - classTypeLookupMap = Map.empty, - ) - - def scalaProject( - compilationUnits: Set[any.CompilationUnit[FT]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = Map.empty, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - ): Project[FT] - - override def ooCompilationUnit( - name: Seq[any.Name[FT]], - imports: Seq[any.Import[FT]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = Map.empty, - classes: Seq[oo.Class[FT]] = Seq.empty, - tests: Seq[any.TestSuite[FT]] = Seq.empty, - ): oo.CompilationUnit[FT] = scalaCompilationUnit( - name = name, - imports = imports, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - classTypeLookupMap = classTypeLookupMap, - adtTypeLookupMap = Map.empty, - functionTypeLookupMap = Map.empty, - classes = classes, - adts = Seq.empty, - functions = Seq.empty, - tests = tests, - ) - - override def funCompilationUnit( - name: Seq[any.Name[FT]], - imports: Seq[any.Import[FT]], - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - adts: Seq[functional.AlgebraicDataType[FT]] = Seq.empty, - functions: Seq[any.Method[FT]] = Seq.empty, - tests: Seq[any.TestSuite[FT]] = Seq.empty, - ): functional.CompilationUnit[FT] = scalaCompilationUnit( - name = name, - imports = imports, - methodTypeLookupMap = Map.empty, - constructorTypeLookupMap = Map.empty, - classTypeLookupMap = Map.empty, - adtTypeLookupMap = adtTypeLookupMap, - functionTypeLookupMap = functionTypeLookupMap, - classes = Seq.empty, - adts = adts, - functions = functions, - tests = tests) - - def scalaCompilationUnit( - name: Seq[any.Name[FT]], - imports: Seq[any.Import[FT]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FT], any.Type[FT]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[oo.Class[FT], any.Type[FT]] = Map.empty, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FT], any.Type[FT]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FT], any.Type[FT]] = Map.empty, - classes: Seq[oo.Class[FT]] = Seq.empty, - adts: Seq[functional.AlgebraicDataType[FT]] = Seq.empty, - functions: Seq[any.Method[FT]] = Seq.empty, - tests: Seq[any.TestSuite[FT]] = Seq.empty, - ): CompilationUnit[FT] - - def name(name: String, mangled: String): Name[FT] - def importStatement(components: Seq[any.Name[FT]]): Import[FT] - - def reifiedScalaValue[T](ofHostType: OfHostType[T], value: T): ReifiedScalaValue[FT, T] - - - override def createNodeExpr(): TreeOps.CreateNodeExpr[FT] = { - createNodeExprWithNodeClass(classReferenceType( - Seq("org", "combinators", "ep", "util", "Node").map(n => name(n, n)):_* - )) - } - def createNodeExprWithNodeClass(nodeClass: oo.ClassReferenceType[FT]): CreateNodeExpr[FT] - - override def createLeaf(): TreeOps.CreateLeaf[FT] = { - createLeafWithLeafClass(classReferenceType( - Seq("org", "combinators", "ep", "util", "Leaf").map(n => name(n, n)):_* - )) - } - def createLeafWithLeafClass(leafClass: oo.ClassReferenceType[FT]): CreateLeaf[FT] - - - - implicit def convert(other: any.Import[FT]): Import[FT] - implicit def convert(other: any.Statement[FT]): Statement[FT] - implicit def convert(other: any.Type[FT]): Type[FT] - implicit def convert(other: any.Name[FT]): Name[FT] - implicit def convert(other: any.Expression[FT]): Expression[FT] - implicit def convert(other: any.ArgumentExpression[FT]): ArgumentExpression[FT] - implicit def convert(other: any.Project[FT]): Project[FT] - implicit def convert(other: any.CompilationUnit[FT]): CompilationUnit[FT] - implicit def convert(other: any.Method[FT]): Method[FT] - implicit def convert(other: functional.control.Lambda[FT]): Lambda[FT] - implicit def convert(other: any.TestSuite[FT]): TestSuite[FT] - implicit def convert(other: oo.Class[FT]): Class[FT] - implicit def convert(other: oo.Constructor[FT]): Constructor[FT] - implicit def convert(other: oo.Field[FT]): Field[FT] - implicit def convert(other: oo.MemberAccessExpression[FT]): MemberAccessExpression[FT] - implicit def convert(other: oo.SelfReferenceExpression[FT]): SelfReferenceExpression[FT] - implicit def convert(other: oo.ObjectInstantiationExpression[FT]): ObjectInstantiationExpression[FT] - implicit def convert(other: oo.CastExpression[FT]): CastExpression[FT] - implicit def convert(other: oo.InstanceOfExpression[FT]): InstanceOfExpression[FT] - implicit def convert(other: oo.SuperReferenceExpression[FT]): SuperReferenceExpression[FT] - implicit def convert(other: functional.AlgebraicDataType[FT]): AlgebraicDataType[FT] - implicit def convert(other: functional.TypeConstructor[FT]): TypeConstructor[FT] - implicit def convert(other: functional.TypeInstantiationExpression[FT]): TypeInstantiationExpression[FT] - implicit def convert(decl: imperative.DeclareVariable[FT]): DeclareVariable[FT] - implicit def convert(other: functional.control.DeclareFunVariable[FT]): DeclareFunVariable[FT] - implicit def convert(assignVariable: imperative.AssignVariable[FT]): AssignVariable[FT] - implicit def convert(ifThenElse: imperative.IfThenElse[FT]): IfThenElse[FT] - implicit def convert(other: functional.control.IfThenElse[FT]): FunIfThenElse[FT] - implicit def convert(whileLoop: imperative.While[FT]): While[FT] - implicit def convert(operator: OperatorExpressionOps.Operator[FT]): Operator[FT] - implicit def convert(binaryExpression: OperatorExpressionOps.BinaryExpression[FT]): BinaryExpression[FT] - implicit def convert(unaryExpression: OperatorExpressionOps.UnaryExpression[FT]): UnaryExpression[FT] - - implicit def convert[T](reifiedScalaValue: ReifiedScalaValue[FT, T]): ReifiedScalaValue[FT, T] - implicit def convert(other: any.ApplyExpression[FT]): ApplyExpression[FT] - implicit def convert(other: oo.ClassReferenceType[FT]): ClassReferenceType[FT] - implicit def convert(varRef: imperative.VariableReferenceExpression[FT]): VariableReferenceExpression[FT] - - override implicit def convert(other: polymorphism.TypeParameter[FT]): TypeParameter[FT] - override implicit def convert(other: polymorphism.TypeReferenceExpression[FT]): TypeReferenceExpression[FT] - override implicit def convert(other: polymorphism.TypeArgument[FT]): TypeArgument[FT] - override implicit def convert(other: polymorphism.TypeApplication[FT]): TypeApplication[FT] - - implicit def convert(other: TreeOps.CreateLeaf[FT]): CreateLeaf[FT] - implicit def convert(other: TreeOps.CreateNodeExpr[FT]): CreateNodeExpr[FT] - - implicit def convert(other: scala.BlockExpression[FT]): scala.BlockExpression[FT] - implicit def convert(other: scala.MethodReferenceExpression[FT]): scala.MethodReferenceExpression[FT] - - implicit def convert(other: functional.control.PatternContext[FT]): scala.PatternContext[FT] - implicit def convert(other: functional.control.PatternVariable[FT]): scala.PatternVariable[FT] - implicit def convert(other: functional.control.ConstructorPattern[FT]): scala.ConstructorPattern[FT] - implicit def convert(other: functional.control.PatternMatch[FT]): scala.PatternMatch[FT] - - - def blockExpression(statements: Seq[any.Statement[FT]]): scala.BlockExpression[FT] - def methodReferenceExpression(qualifiedMethodName: Seq[any.Name[FT]]): scala.MethodReferenceExpression[FT] - - } - - - object Finalized { - class FinalTypes extends scala.FinalTypes { - override type DeclareVariable = Finalized.DeclareVariable - override type DeclareFunVariable = Finalized.DeclareFunVariable - override type AssignVariable = Finalized.AssignVariable - override type IfThenElse = Finalized.IfThenElse - override type FunIfThenElse = Finalized.FunIfThenElse - override type While = Finalized.While - override type Class = Finalized.Class - override type Constructor = Finalized.Constructor - override type Field = Finalized.Field - override type MemberAccessExpression = Finalized.MemberAccessExpression - override type SelfReferenceExpression = Finalized.SelfReferenceExpression - override type ObjectInstantiationExpression = Finalized.ObjectInstantiationExpression - override type CastExpression = Finalized.CastExpression - override type InstanceOfExpression = Finalized.InstanceOfExpression - override type SuperReferenceExpression = Finalized.SuperReferenceExpression - override type Operator = Finalized.Operator - override type BinaryExpression = Finalized.BinaryExpression - override type UnaryExpression = Finalized.UnaryExpression - override type Import = Finalized.Import - override type Statement = Finalized.Statement - override type Type = Finalized.Type - override type Name = Finalized.Name - override type Expression = Finalized.Expression - override type ApplyExpression = Finalized.ApplyExpression - override type ArgumentExpression = Finalized.ArgumentExpression - override type CompilationUnit = Finalized.CompilationUnit - override type Project = Finalized.Project - override type Method = scala.Method[FinalTypes] - override type Lambda = Finalized.Lambda - override type ReifiedScalaValue[T] = Finalized.ReifiedScalaValue[T] - override type ClassReferenceType = Finalized.ClassReferenceType - override type VariableReferenceExpression = Finalized.VariableReferenceExpression - override type TypeParameter = Finalized.TypeParameter - override type TypeReferenceExpression = Finalized.TypeReferenceExpression - override type TypeArgument = Finalized.TypeArgument - override type TypeApplication = Finalized.TypeApplication - override type CreateLeaf = Finalized.CreateLeaf - override type CreateNodeExpr = Finalized.CreateNodeExpr - override type BlockExpression = Finalized.BlockExpression - override type TestSuite = Finalized.TestSuite - override type ADTReferenceType = Finalized.ADTReferenceType - override type AlgebraicDataType = Finalized.AlgebraicDataType - override type TypeConstructor = Finalized.TypeConstructor - override type TypeInstantiationExpression = Finalized.TypeInstantiationExpression - override type MethodReferenceExpression = Finalized.MethodReferenceExpression - override type PatternContext = Finalized.PatternContext - override type PatternVariable = Finalized.PatternVariable - override type ConstructorPattern = Finalized.ConstructorPattern - override type PatternMatch = Finalized.PatternMatch - } - - trait Factory extends scala.Factory[FinalTypes] { - val finalTypes: FinalTypes = new FinalTypes - - override def scalaProject( - compilationUnits: Set[any.CompilationUnit[FinalTypes]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]] = Map.empty, - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]] = Map.empty, - classTypeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]] = Map.empty, - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FinalTypes], any.Type[FinalTypes]] = Map.empty, - functionTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]] = Map.empty, - ): Project = - Project(compilationUnits, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap, adtTypeLookupMap, functionTypeLookupMap) - - def name(name: String, mangled: String): Name = Name(name, mangled) - override def importStatement(components: Seq[any.Name[FinalTypes]]): Import = Import(components) - override def binaryExpression(operator: OperatorExpressionOps.Operator[FinalTypes], left: any.Expression[FinalTypes], right: any.Expression[FinalTypes]): OperatorExpressionOps.BinaryExpression[FinalTypes] = BinaryExpression(operator, left, right) - override def unaryExpression(operator: OperatorExpressionOps.Operator[FinalTypes], operand: any.Expression[FinalTypes]): OperatorExpressionOps.UnaryExpression[FinalTypes] = UnaryExpression(operator, operand) - implicit def convert(operator: OperatorExpressionOps.Operator[FinalTypes]): Operator = operator.getSelfOperator - implicit def convert(binaryExpression: OperatorExpressionOps.BinaryExpression[FinalTypes]): BinaryExpression = binaryExpression.getSelfBinaryExpression - implicit def convert(unaryExpression: OperatorExpressionOps.UnaryExpression[FinalTypes]): UnaryExpression = unaryExpression.getSelfUnaryExpression - /*override def scalaCompilationUnit( - name: Seq[any.Name[FinalTypes]], - imports: Seq[any.Import[FinalTypes]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]], - classTypeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]], - adtTypeLookupMap: TypeRep => Generator[scala.AlgebraicDataType[FinalTypes], any.Type[FinalTypes]], - functionTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - classes: Seq[oo.Class[FinalTypes]], - adts: Seq[scala.AlgebraicDataType[FinalTypes]], - functions: Seq[any.Method[FinalTypes]], - tests: Seq[any.TestSuite[FinalTypes]], - ): CompilationUnit*/ - def scalaCompilationUnit( - name: Seq[any.Name[FinalTypes]], - imports: Seq[any.Import[FinalTypes]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes],any.Type[FinalTypes]], - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes],any.Type[FinalTypes]], - classTypeLookupMap: TypeRep => Generator[oo.Class[FinalTypes],any.Type[FinalTypes]], - adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FinalTypes],any.Type[FinalTypes]], - functionTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes],any.Type[FinalTypes]], - classes: Seq[oo.Class[FinalTypes]], - adts: Seq[functional.AlgebraicDataType[FinalTypes]], - functions: Seq[any.Method[FinalTypes]], - tests: Seq[any.TestSuite[FinalTypes]]): CompilationUnit = CompilationUnit( - name = name, - imports = imports, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - classTypeLookupMap = classTypeLookupMap, - adtTypeLookupMap = adtTypeLookupMap, - functionTypeLookupMap = functionTypeLookupMap, - classes = classes, - adts = adts, - functions = functions, - tests = tests - ) - - override def constructor( - constructedType: Option[any.Type[FinalTypes]], - imports: Set[any.Import[FinalTypes]], - statements: Seq[any.Statement[FinalTypes]], - parameters: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])], - typeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]], - superInitialization: Option[(any.Type[FinalTypes], Seq[any.Expression[FinalTypes]])], - fieldInitializers: Seq[(any.Name[FinalTypes], any.Expression[FinalTypes])]): Constructor = - Constructor( - constructedType = constructedType, - imports = imports, - statements = statements, - parameters = parameters, - typeLookupMap = typeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - superInitialization = superInitialization, - fieldInitializers = fieldInitializers - ) - - override def field(name: any.Name[FinalTypes], tpe: any.Type[FinalTypes], init: Option[any.Expression[FinalTypes]]): oo.Field[FinalTypes] = Field(name, tpe, init) - override def memberAccessExpression(owner: any.Expression[FinalTypes], field: any.Name[FinalTypes]): MemberAccessExpression = MemberAccessExpression(owner, field) - - override def objectInstantiationExpression(tpe: any.Type[FinalTypes], constructorArguments: Seq[any.Expression[FinalTypes]], body: Option[oo.Class[FinalTypes]] = Option.empty): oo.ObjectInstantiationExpression[FinalTypes] = - ObjectInstantiationExpression(tpe, constructorArguments, body) - override def castExpression(tpe: any.Type[FinalTypes], expression: any.Expression[FinalTypes]): oo.CastExpression[FinalTypes] = CastExpression(tpe, expression) - override def instanceOfExpression(tpe: any.Type[FinalTypes], expression: any.Expression[FinalTypes]): oo.InstanceOfExpression[FinalTypes] = InstanceOfExpression(tpe, expression) - override def superReferenceExpression(parentType: any.Type[FinalTypes]): oo.SuperReferenceExpression[FinalTypes] = SuperReferenceExpression(parentType) - override def selfReferenceExpression: oo.SelfReferenceExpression[FinalTypes] = SelfReferenceExpression() - implicit def convert(other: any.Project[FinalTypes]): Project = other.getSelfProject - implicit def convert(other: any.CompilationUnit[FinalTypes]): CompilationUnit = other.getSelfCompilationUnit - implicit def convert(other: any.Method[FinalTypes]): scala.Method[FinalTypes] = other.getSelfMethod - implicit def convert(other: any.TestSuite[FinalTypes]): scala.TestSuite[FinalTypes] = other.getSelfTestSuite - implicit def convert(other: oo.Class[FinalTypes]): Class = other.getSelfClass - implicit def convert(other: oo.Constructor[FinalTypes]): Constructor = other.getSelfConstructor - implicit def convert(other: oo.Field[FinalTypes]): Field = other.getSelfField - implicit def convert(other: oo.MemberAccessExpression[FinalTypes]): MemberAccessExpression = other.getSelfMemberAccessExpression - implicit def convert(other: oo.SelfReferenceExpression[FinalTypes]): SelfReferenceExpression = other.getSelfSelfReferenceExpression - implicit def convert(other: oo.ObjectInstantiationExpression[FinalTypes]): ObjectInstantiationExpression = other.getSelfObjectInstantiationExpression - implicit def convert(other: oo.CastExpression[FinalTypes]): CastExpression = other.getSelfCastExpression - implicit def convert(other: oo.InstanceOfExpression[FinalTypes]): InstanceOfExpression = other.getSelfInstanceOfExpression - implicit def convert(other: oo.SuperReferenceExpression[FinalTypes]): SuperReferenceExpression = other.getSelfSuperReferenceExpression - override def addOp(): ArithmeticOps.AddOp[FinalTypes] = AddOp() - override def subOp(): ArithmeticOps.SubOp[FinalTypes] = SubOp() - override def multOp(): ArithmeticOps.MultOp[FinalTypes] = MultOp() - override def divOp(): ArithmeticOps.DivOp[FinalTypes] = DivOp() - override def modOp(): ArithmeticOps.ModOp[FinalTypes] = ModOp() - def sqrtOp(): RealArithmeticOps.SqrtOp[FinalTypes] = SqrtOp() - def powOp(): RealArithmeticOps.PowOp[FinalTypes] = PowOp() - def logOp(): RealArithmeticOps.LogOp[FinalTypes] = LogOp() - def sinOp(): RealArithmeticOps.SinOp[FinalTypes] = SinOp() - def cosOp(): RealArithmeticOps.CosOp[FinalTypes] = CosOp() - def absOp(): RealArithmeticOps.AbsOp[FinalTypes] = AbsOp() - def floorOp(): RealArithmeticOps.FloorOp[FinalTypes] = FloorOp() - def pi(): RealArithmeticOps.Pi[FinalTypes] = Pi() - def eulersNumber(): RealArithmeticOps.EulersNumber[FinalTypes] = EulersNumber() - override def ltOp(): ArithmeticOps.LtOp[FinalTypes] = LtOp() - override def leOp(): ArithmeticOps.LeOp[FinalTypes] = LeOp() - override def equals(tpe: any.Type[FinalTypes], left: any.Expression[FinalTypes], right: any.Expression[FinalTypes]): EqualsOps.Equals[FinalTypes] = Equals(tpe, left, right) - override def andOp(): BooleanOps.AndOp[FinalTypes] = AndOp() - override def orOp(): BooleanOps.OrOp[FinalTypes] = OrOp() - override def notOp(): BooleanOps.NotOp[FinalTypes] = NotOp() - override def trueExp(): BooleanOps.True[FinalTypes] = True() - override def falseExp(): BooleanOps.False[FinalTypes] = False() - override def declareVariable(name: any.Name[FinalTypes], tpe: any.Type[FinalTypes], initializer: Option[any.Expression[FinalTypes]]): imperative.DeclareVariable[FinalTypes] = - DeclareVariable(name, tpe, initializer) - override def assignVariable(variable: any.Expression[FinalTypes], expression: any.Expression[FinalTypes]): imperative.AssignVariable[FinalTypes] = - AssignVariable(variable, expression) - override def liftExpression(expression: any.Expression[FinalTypes]): imperative.LiftExpression[FinalTypes] = - LiftExpression(expression) - override def returnExpression(expression: any.Expression[FinalTypes]): any.Return[FinalTypes] = - Return(expression) - override def ifThenElse(condition: any.Expression[FinalTypes], ifBranch: Seq[any.Statement[FinalTypes]], elseIfBranches: Seq[(any.Expression[FinalTypes], Seq[any.Statement[FinalTypes]])], elseBranch: Seq[any.Statement[FinalTypes]]): imperative.IfThenElse[FinalTypes] = - IfThenElse(condition, ifBranch, elseIfBranches, elseBranch) - override def whileLoop(condition: any.Expression[FinalTypes], body: Seq[any.Statement[FinalTypes]]): imperative.While[FinalTypes] = - While(condition, body) - implicit def convert(decl: imperative.DeclareVariable[FinalTypes]): DeclareVariable = decl.getSelfDeclareVariable - implicit def convert(assignVariable: imperative.AssignVariable[FinalTypes]): AssignVariable = assignVariable.getSelfAssignVariable - implicit def convert(ifThenElse: imperative.IfThenElse[FinalTypes]): IfThenElse = ifThenElse.getSelfIfThenElse - implicit def convert(whileLoop: imperative.While[FinalTypes]): While = whileLoop.getSelfWhile - override def toStringOp(): StringOps.ToStringOp[FinalTypes] = ToStringOp() - override def appendStringOp(): StringOps.AppendStringOp[FinalTypes] = AppendStringOp() - override def stringLengthOp(): StringOps.StringLengthOp[FinalTypes] = StringLengthOp() - override def assertTrueOp(): AssertionOps.AssertTrueOp[FinalTypes] = AssertTrueOp() - - override def ooProject(compilationUnits: Set[any.CompilationUnit[FinalTypes]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]], - classTypeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]]): oo.Project[FinalTypes] = Project(compilationUnits, methodTypeLookupMap, constructorTypeLookupMap, classTypeLookupMap) - override def argumentExpression(parameterName: any.Name[FinalTypes]): any.ArgumentExpression[FinalTypes] = ArgumentExpression(parameterName) - implicit def convert(other: any.Import[FinalTypes]): Import = other.getSelfImport - implicit def convert(other: any.Statement[FinalTypes]): Statement = other.getSelfStatement - implicit def convert(other: any.Type[FinalTypes]): Type = other.getSelfType - implicit def convert(other: any.Name[FinalTypes]): Name = other.getSelfName - implicit def convert(other: any.Expression[FinalTypes]): Expression = other.getSelfExpression - implicit def convert(other: any.ArgumentExpression[FinalTypes]): ArgumentExpression = other.getSelfArgumentExpression - implicit def convert(other: scala.BlockExpression[FinalTypes]): BlockExpression = other.getSelfBlockExpression - implicit def convert(other: scala.MethodReferenceExpression[FinalTypes]): MethodReferenceExpression = other.getSelfAsMethodReferenceExpression - - override def blockExpression(statements: Seq[any.Statement[FinalTypes]]): BlockExpression = BlockExpression(statements) - override def methodReferenceExpression(qualifiedMethodName: Seq[any.Name[FinalTypes]]): MethodReferenceExpression = MethodReferenceExpression(qualifiedMethodName) - - override def reifiedScalaValue[T](ofHostType: OfHostType[T], value: T): ReifiedScalaValue[T] = ReifiedScalaValue(ofHostType, value) - implicit def convert[T](other: scala.ReifiedScalaValue[FinalTypes, T]): ReifiedScalaValue[T] = other.getSelfAsReifiedScalaValue - implicit def convert(other: any.ApplyExpression[FinalTypes]): ApplyExpression = other.getSelfApplyExpression - implicit def convert(other: oo.ClassReferenceType[FinalTypes]): ClassReferenceType = other.getSelfClassReferenceType - implicit def convert(other: functional.ADTReferenceType[FinalTypes]): ADTReferenceType = other.getSelfADTReferenceType - implicit def convert(varRef: imperative.VariableReferenceExpression[FinalTypes]): VariableReferenceExpression = varRef.getSelfVariableReferenceExpression - override def variableReferenceExpression(name: any.Name[FinalTypes]): imperative.VariableReferenceExpression[FinalTypes] = VariableReferenceExpression(name) - - override def classReferenceType(qualifiedClassName: any.Name[FinalTypes]*): oo.ClassReferenceType[FinalTypes] = ClassReferenceType(qualifiedClassName) - override def adtReferenceType(qualifiedTypeName: any.Name[FinalTypes]*): functional.ADTReferenceType[FinalTypes] = ADTReferenceType(qualifiedTypeName) - override def applyExpression(function: any.Expression[FinalTypes], arguments: Seq[any.Expression[FinalTypes]]): any.ApplyExpression[FinalTypes] = ApplyExpression(function, arguments) - - override def convert(other: polymorphism.TypeParameter[FinalTypes]): TypeParameter = other.getSelfTypeParameter - - override implicit def convert(other: polymorphism.TypeReferenceExpression[FinalTypes]): TypeReferenceExpression = other.getSelfTypeReferenceExpression - - override implicit def convert(other: polymorphism.TypeArgument[FinalTypes]): TypeArgument = other.getSelfTypeArgument - - override implicit def convert(other: polymorphism.TypeApplication[FinalTypes]): TypeApplication = other.getSelfTypeApplication - - override def genericClass(name: any.Name[FinalTypes], - imports: Seq[any.Import[FinalTypes]], - typeParameters: Seq[polymorphism.TypeParameter[FinalTypes]], - parents: Seq[any.Type[FinalTypes]], - implemented: Seq[any.Type[FinalTypes]], - fields: Seq[oo.Field[FinalTypes]], - methods: Seq[any.Method[FinalTypes]], - constructors: Seq[oo.Constructor[FinalTypes]], - methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]], - typeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]], - isAbstract: Boolean, - isInterface: Boolean, - isStatic: Boolean): oo.Class[FinalTypes] = - Class( - name = name, - typeParameters = typeParameters, - imports = imports, - parents = parents, - implemented = implemented, - fields = fields, - methods = methods, - constructors = constructors, - methodTypeLookupMap = methodTypeLookupMap, - constructorTypeLookupMap = constructorTypeLookupMap, - typeLookupMap = typeLookupMap, - isAbstract = isAbstract, - isInterface = isInterface, - isStatic = isStatic) - - override def genericMethod( - name: any.Name[FinalTypes], - imports: Set[any.Import[FinalTypes]], - statements: Seq[any.Statement[FinalTypes]], - returnType: Option[any.Type[FinalTypes]], - typeParameters: Seq[polymorphism.TypeParameter[FinalTypes]], - parameters: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])], - typeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - isAbstract: Boolean, - isStatic: Boolean, - isPublic: Boolean, - isOverride: Boolean): generics.Method[FinalTypes] = - Method( - name = name, - typeParameters = typeParameters, - imports = imports, - statements = statements, - returnType = returnType, - parameters = parameters, - typeLookupMap = typeLookupMap, - isAbstract = isAbstract, - isStatic = isStatic, - isPublic = isPublic, - isOverride = isOverride - ) - - override def lambda( - variables: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])], - body: any.Expression[FinalTypes] - ): functional.control.Lambda[FinalTypes] = Lambda(variables, body) - - override def adt( - name: any.Name[FinalTypes], - imports: Seq[any.Import[FinalTypes]], - typeConstructors: Seq[functional.TypeConstructor[FinalTypes]], - typeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FinalTypes], any.Type[FinalTypes]] - ): functional.AlgebraicDataType[FinalTypes] = AlgebraicDataType( - name, - imports, - typeConstructors, - typeLookupMap - ) - - override def typeConstructor( - name: any.Name[FinalTypes], - parameters: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])] = Seq.empty - ): functional.TypeConstructor[FinalTypes] = TypeConstructor( - name = name, - parameters = parameters - ) - - override def typeInstantiationExpression( - tpe: any.Type[FinalTypes], - constructorName: Seq[any.Name[FinalTypes]], - constructorArguments: Seq[any.Expression[FinalTypes]] = Seq.empty - ): functional.TypeInstantiationExpression[FinalTypes] = TypeInstantiationExpression( - tpe = tpe, - constructorName = constructorName, - constructorArguments = constructorArguments, - ) - - implicit override def convert(other: functional.AlgebraicDataType[FinalTypes]): AlgebraicDataType = other.getSelfAlgebraicDataType - implicit override def convert(other: functional.TypeConstructor[FinalTypes]): TypeConstructor = other.getSelfTypeConstructor - implicit override def convert(other: functional.TypeInstantiationExpression[FinalTypes]): TypeInstantiationExpression = other.getSelfTypeInstantiationExpression - - override def typeParameterWithBounds(name: any.Name[FinalTypes], upperBounds: Seq[any.Type[FinalTypes]], lowerBounds: Seq[any.Type[FinalTypes]]): TypeParameter = - TypeParameter(name, upperBounds = upperBounds, lowerBounds = lowerBounds) - override def createList(): ListOps.CreateList[FinalTypes] = CreateList() - - override def consListOp(): ListOps.ConsListOp[FinalTypes] = ConsListOp() - - override def headListOp(): ListOps.HeadListOp[FinalTypes] = HeadListOp() - - override def tailListOp(): ListOps.TailListOp[FinalTypes] = TailListOp() - - override def appendListOp(): ListOps.AppendListOp[FinalTypes] = AppendListOp() - - override def typeArgument(name: any.Name[FinalTypes]): TypeArgument = - TypeArgument(name) - - override def typeApplication(function: any.Type[FinalTypes], arguments: Seq[any.Type[FinalTypes]]): TypeApplication = - TypeApplication(function, arguments) - - override def typeReferenceExpression(tpe: any.Type[FinalTypes]): TypeReferenceExpression = - TypeReferenceExpression(tpe) - def createNodeExprWithNodeClass(nodeClass: oo.ClassReferenceType[FinalTypes]): scala.CreateNodeExpr[FinalTypes] = CreateNodeExpr(nodeClass) - def createLeafWithLeafClass(leafClass: oo.ClassReferenceType[FinalTypes]): scala.CreateLeaf[FinalTypes] = CreateLeaf(leafClass) - implicit def convert(other: TreeOps.CreateLeaf[FinalTypes]): scala.CreateLeaf[FinalTypes] = other.getSelfCreateLeaf - implicit def convert(other: TreeOps.CreateNodeExpr[FinalTypes]): scala.CreateNodeExpr[FinalTypes] = other.getSelfCreateNodeExpr - - override def classBasedTestSuite(underlyingClass: oo.Class[FinalTypes], testMarkers: Seq[Boolean]): TestSuite = TestSuite(underlyingClass, testMarkers) - - def constructorPattern( - tpe: any.Type[FinalTypes], - constructor: any.Name[FinalTypes], - arguments: Seq[any.Expression[FinalTypes]] - ): ConstructorPattern = ConstructorPattern(tpe, constructor, arguments) - implicit def convert(other: functional.control.ConstructorPattern[FinalTypes]): scala.ConstructorPattern[FinalTypes] = other.getSelfConstructorPattern - def patternVariable(name: any.Name[FinalTypes]): scala.PatternVariable[FinalTypes] = PatternVariable(name) - implicit def convert(other: functional.control.PatternVariable[FinalTypes]): scala.PatternVariable[FinalTypes] = other.getSelfPatternVariable - def patternContext(variables: Seq[any.Name[FinalTypes]]): scala.PatternContext[FinalTypes] = PatternContext(variables) - implicit def convert(other: functional.control.PatternContext[FinalTypes]): scala.PatternContext[FinalTypes] = other.getSelfPatternContext - implicit def convert(other: functional.control.Lambda[FinalTypes]): Lambda = other.getSelfLambda - implicit def convert(other: functional.control.DeclareFunVariable[FinalTypes]): DeclareFunVariable = other.getSelfDeclareFunVariable - def declareFunVariable( - name: any.Name[FinalTypes], - tpe: any.Type[FinalTypes], - isRecursive: Boolean, - initializer: any.Expression[FinalTypes], - inExp: any.Expression[FinalTypes]): functional.control.DeclareFunVariable[FinalTypes] = DeclareFunVariable(name, tpe, isRecursive = isRecursive, initializer, inExp) - def funIfThenElse( - condition: any.Expression[FinalTypes], - ifBranch: any.Expression[FinalTypes], - elseIfBranches: Seq[(any.Expression[FinalTypes], any.Expression[FinalTypes])], - elseBranch: any.Expression[FinalTypes] - ): scala.FunIfThenElse[FinalTypes] = FunIfThenElse(condition, ifBranch, elseIfBranches, elseBranch) - - implicit def convert(other: functional.control.IfThenElse[FinalTypes]): FunIfThenElse = other.getSelfFunIfThenElse - def patternMatch( - onValue: any.Expression[FinalTypes], - cases: Seq[(any.Expression[FinalTypes], any.Expression[FinalTypes])] = Seq.empty - ): scala.PatternMatch[FinalTypes] = PatternMatch(onValue, cases) - implicit def convert(other: functional.control.PatternMatch[FinalTypes]): PatternMatch = other.getSelfPatternMatch - } - - case class Name(override val component: String, override val mangled: String) extends scala.Name[FinalTypes] with Factory { - override def getSelfName: this.type = this - } - - trait Util extends scala.Util[FinalTypes] with Factory { - override def nameProvider: NameProvider[any.Name[FinalTypes]] = new ScalaNameProvider[FinalTypes](this) - } - - case class Method( - override val name: any.Name[FinalTypes], - override val typeParameters: Seq[polymorphism.TypeParameter[FinalTypes]], - override val imports: Set[any.Import[FinalTypes]], - override val statements: Seq[any.Statement[FinalTypes]], - override val returnType: Option[any.Type[FinalTypes]], - override val parameters: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])], - override val typeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - override val isAbstract: Boolean, - override val isStatic: Boolean, - override val isPublic: Boolean, - override val isOverride: Boolean - ) extends scala.Method[FinalTypes] with Util { - def getSelfMethod: this.type = this - } - - case class Import(override val components: Seq[any.Name[FinalTypes]]) extends scala.Import[FinalTypes] with Factory { - def getSelfImport: this.type = this - } - - trait Type extends scala.Type[FinalTypes] with Factory { - def getSelfType: this.type = this - } - - case class ClassReferenceType(override val qualifiedClassName: Seq[any.Name[FinalTypes]]) extends scala.ClassReferenceType[FinalTypes] with Type with Factory { - def getSelfClassReferenceType: this.type = this - } - - case class AlgebraicDataType( - override val name: any.Name[FinalTypes], - override val imports: Seq[any.Import[FinalTypes]] = Seq.empty, - override val typeConstructors: Seq[functional.TypeConstructor[FinalTypes]] = Seq.empty, - override val typeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FinalTypes], any.Type[FinalTypes]] = Map.empty, - ) extends scala.AlgebraicDataType[FinalTypes] with Type with Factory with Util { - def getSelfAlgebraicDataType: this.type = this - } - - case class TypeConstructor( - override val name: any.Name[FinalTypes], - override val parameters: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])] = Seq.empty - ) extends scala.TypeConstructor[FinalTypes] with Factory { - def getSelfTypeConstructor: this.type = this - } - - case class TypeInstantiationExpression( - override val tpe: any.Type[FinalTypes], - override val constructorName: Seq[any.Name[FinalTypes]], - override val constructorArguments: Seq[any.Expression[FinalTypes]] = Seq.empty - ) extends scala.TypeInstantiationExpression[FinalTypes] with Expression { - def getSelfTypeInstantiationExpression: this.type = this - } - - case class ADTReferenceType(override val qualifiedTypeName: Seq[any.Name[FinalTypes]]) extends scala.ADTReferenceType[FinalTypes] with Type with Factory { - def getSelfADTReferenceType: this.type = this - } - - trait Operator extends scala.Operator[FinalTypes] with Factory { - override def getSelfOperator: this.type = this - } - - trait Expression extends scala.Expression[FinalTypes] with Factory { - override def getSelfExpression: this.type = this - } - - case class BinaryExpression( - override val operator: OperatorExpressionOps.Operator[FinalTypes], - override val left: any.Expression[FinalTypes], - override val right: any.Expression[FinalTypes] - ) - extends Expression with scala.BinaryExpression[FinalTypes] with Factory { - override def getSelfBinaryExpression: this.type = this - - } - - case class UnaryExpression( - override val operator: OperatorExpressionOps.Operator[FinalTypes], - override val operand: any.Expression[FinalTypes] - ) - extends Expression with scala.UnaryExpression[FinalTypes] with Factory { - override def getSelfUnaryExpression: this.type = this - } - - case class ReifiedScalaValue[T]( - override val ofHostType: OfHostType[T], - override val value: T - ) extends Expression with scala.ReifiedScalaValue[FinalTypes, T] with Factory { - override def getSelfAsReifiedScalaValue: this.type = this - } - - trait Statement extends scala.Statement[FinalTypes] with Factory { - def getSelfStatement: this.type = this - } - - case class DeclareVariable( - override val name: any.Name[FinalTypes], - override val tpe: any.Type[FinalTypes], - override val initializer: Option[any.Expression[FinalTypes]] - ) extends Statement with scala.DeclareVariable[FinalTypes] with Factory { - override def getSelfDeclareVariable: this.type = this - } - - case class AssignVariable( - override val variable: any.Expression[FinalTypes], - override val assignmentExpression: any.Expression[FinalTypes] - ) extends Statement with scala.AssignVariable[FinalTypes] with Factory { - override def getSelfAssignVariable: this.type = this - } - - case class IfThenElse( - override val condition: any.Expression[FinalTypes], - override val ifBranch: Seq[any.Statement[FinalTypes]], - override val elseIfBranches: Seq[(any.Expression[FinalTypes], Seq[any.Statement[FinalTypes]])], - override val elseBranch: Seq[any.Statement[FinalTypes]] - ) extends Statement with scala.IfThenElse[FinalTypes] with Factory { - override def getSelfIfThenElse: this.type = this - } - - case class While( - override val condition: any.Expression[FinalTypes], - override val body: Seq[any.Statement[FinalTypes]] - ) extends Statement with scala.While[FinalTypes] with Factory { - override def getSelfWhile: this.type = this - } - - - case class Class( - override val name: any.Name[FinalTypes], - override val typeParameters: Seq[polymorphism.TypeParameter[FinalTypes]], - override val imports: Seq[any.Import[FinalTypes]] = Seq.empty, - override val parents: Seq[any.Type[FinalTypes]] = Seq.empty, - override val implemented: Seq[any.Type[FinalTypes]] = Seq.empty, - override val fields: Seq[oo.Field[FinalTypes]] = Seq.empty, - override val methods: Seq[any.Method[FinalTypes]] = Seq.empty, - override val constructors: Seq[oo.Constructor[FinalTypes]] = Seq.empty, - override val methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]], - override val typeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val isAbstract: Boolean = false, - override val isInterface: Boolean = false, - override val isStatic: Boolean = false - ) extends scala.Class[FinalTypes] with Util { - override def getSelfClass: this.type = this - } - - case class Constructor( - override val constructedType: Option[any.Type[FinalTypes]], - override val imports: Set[any.Import[FinalTypes]], - override val statements: Seq[any.Statement[FinalTypes]], - override val parameters: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])], - override val typeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]], - override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]], - override val superInitialization: Option[(any.Type[FinalTypes], Seq[any.Expression[FinalTypes]])], - override val fieldInitializers: Seq[(any.Name[FinalTypes], any.Expression[FinalTypes])]) extends scala.Constructor[FinalTypes] with Util { - override def getSelfMethod: scala.Method[FinalTypes] = this - override def getSelfConstructor: this.type = this - override def toScala: String = { - super[Constructor].toScala - } - } - - case class Field( - override val name: any.Name[FinalTypes], - override val tpe: any.Type[FinalTypes], - override val init: Option[any.Expression[FinalTypes]] = Option.empty - ) extends scala.Field[FinalTypes] with Factory { - override def getSelfField: this.type = this - } - - case class MemberAccessExpression( - override val owner: any.Expression[FinalTypes], - override val field: any.Name[FinalTypes] - ) extends Expression with scala.MemberAccessExpression[FinalTypes] with Factory { - override def getSelfMemberAccessExpression: this.type = this - } - - case class SelfReferenceExpression() extends Expression with scala.SelfReferenceExpression[FinalTypes] with Factory { - override def getSelfSelfReferenceExpression: this.type = this - } - - case class ObjectInstantiationExpression( - override val tpe: any.Type[FinalTypes], - override val constructorArguments: Seq[any.Expression[FinalTypes]], - override val body: Option[oo.Class[FinalTypes]] = Option.empty - ) extends Expression with scala.ObjectInstantiationExpression[FinalTypes] with Factory { - override def getSelfObjectInstantiationExpression: this.type = this - } - - case class CastExpression( - override val tpe: any.Type[FinalTypes], - override val expression: any.Expression[FinalTypes] - ) extends Expression with scala.CastExpression[FinalTypes] with Factory { - override def getSelfCastExpression: this.type = this - } - - case class InstanceOfExpression( - override val tpe: any.Type[FinalTypes], - override val expression: any.Expression[FinalTypes] - ) extends Expression with scala.InstanceOfExpression[FinalTypes] with Factory { - override def getSelfInstanceOfExpression: this.type = this - } - - case class SuperReferenceExpression( - override val parentType: any.Type[FinalTypes] - ) extends Expression with scala.SuperReferenceExpression[FinalTypes] with Factory { - override def getSelfSuperReferenceExpression: this.type = this - } - - case class ArgumentExpression( - override val parameterName: any.Name[FinalTypes] - ) extends Expression with scala.ArgumentExpression[FinalTypes] with Factory { - override def getSelfArgumentExpression: this.type = this - } - - case class CompilationUnit( - override val name: Seq[any.Name[FinalTypes]] = Seq.empty, - override val imports: Seq[any.Import[FinalTypes]] = Seq.empty, - override val methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val classTypeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val functionTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val classes: Seq[oo.Class[FinalTypes]] = Seq.empty, - override val adts: Seq[functional.AlgebraicDataType[FinalTypes]] = Seq.empty, - override val functions: Seq[any.Method[FinalTypes]] = Seq.empty, - override val tests: Seq[any.TestSuite[FinalTypes]] = Seq.empty, - ) extends scala.CompilationUnit[FinalTypes] with Util { - override def getSelfCompilationUnit: this.type = this - } - - case class Project( - override val compilationUnits: Set[any.CompilationUnit[FinalTypes]], - override val methodTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val constructorTypeLookupMap: TypeRep => Generator[oo.Constructor[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val classTypeLookupMap: TypeRep => Generator[oo.Class[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val adtTypeLookupMap: TypeRep => Generator[functional.AlgebraicDataType[FinalTypes], any.Type[FinalTypes]] = Map.empty, - override val functionTypeLookupMap: TypeRep => Generator[any.Method[FinalTypes], any.Type[FinalTypes]] = Map.empty, - ) extends scala.Project[FinalTypes] with Factory { - override def getSelfProject: this.type = this - } - - - case class AddOp() extends scala.AddOp[FinalTypes] with Operator with Factory - - case class SubOp() extends scala.SubOp[FinalTypes] with Operator with Factory - - case class MultOp() extends scala.MultOp[FinalTypes] with Operator with Factory - - case class DivOp() extends scala.DivOp[FinalTypes] with Operator with Factory - - case class ModOp() extends scala.ModOp[FinalTypes] with Operator with Factory - - case class LtOp() extends scala.LtOp[FinalTypes] with Operator with Factory - case class LeOp() extends scala.LeOp[FinalTypes] with Operator with Factory - - case class SqrtOp() extends scala.SqrtOp[FinalTypes] with Operator with Factory - case class PowOp() extends scala.PowOp[FinalTypes] with Operator with Factory - case class LogOp() extends scala.LogOp[FinalTypes] with Operator with Factory - case class SinOp() extends scala.SinOp[FinalTypes] with Operator with Factory - case class CosOp() extends scala.CosOp[FinalTypes] with Operator with Factory - case class AbsOp() extends scala.AbsOp[FinalTypes] with Operator with Factory - case class FloorOp() extends scala.FloorOp[FinalTypes] with Operator with Factory - - case class EulersNumber() extends scala.EulersNumber[FinalTypes] with Expression with Factory - - case class Pi() extends scala.Pi[FinalTypes] with Expression with Factory - - case class Equals( - override val tpe: any.Type[FinalTypes], - override val left: any.Expression[FinalTypes], - override val right: any.Expression[FinalTypes] - ) extends scala.Equals[FinalTypes] with Expression with Factory - - case class AndOp() extends scala.AndOp[FinalTypes] with Operator with Factory - case class OrOp() extends scala.OrOp[FinalTypes] with Operator with Factory - case class NotOp() extends scala.NotOp[FinalTypes] with Operator with Factory - case class True() extends scala.True[FinalTypes] with Expression with Factory - case class False() extends scala.False[FinalTypes] with Expression with Factory - - case class Return(expression: any.Expression[FinalTypes]) extends scala.Return[FinalTypes] with Statement with Factory - case class LiftExpression(expression: any.Expression[FinalTypes]) extends scala.LiftExpression[FinalTypes] with Statement with Factory - - case class ToStringOp() extends scala.ToStringOp[FinalTypes] with Operator - - case class AppendStringOp() extends scala.AppendStringOp[FinalTypes] with Operator - - case class StringLengthOp() extends scala.StringLengthOp[FinalTypes] with Operator - - case class AssertTrueOp() extends scala.AssertTrueOp[FinalTypes] with Operator - - case class ApplyExpression( - override val function: any.Expression[FinalTypes], - override val arguments: Seq[any.Expression[FinalTypes]] - ) extends scala.ApplyExpression[FinalTypes] with Expression { - override def getSelfApplyExpression: this.type = this - } - - case class VariableReferenceExpression(override val name: any.Name[FinalTypes]) extends scala.VariableReferenceExpression[FinalTypes] with Expression with Factory { - override def getSelfVariableReferenceExpression: this.type = this - } - - case class TypeParameter(override val name: any.Name[FinalTypes], override val upperBounds: Seq[any.Type[FinalTypes]], override val lowerBounds: Seq[any.Type[FinalTypes]]) extends scala.TypeParameter[FinalTypes] with Factory { - override def getSelfTypeParameter: this.type = this - } - - case class TypeArgument(override val name: any.Name[FinalTypes]) extends scala.TypeArgument[FinalTypes] with Type with Factory { - override def getSelfTypeArgument: this.type = this - } - - case class TypeReferenceExpression(override val tpe: any.Type[FinalTypes]) extends scala.TypeReferenceExpression[FinalTypes] with Expression with Factory { - override def getSelfTypeReferenceExpression: this.type = this - } - - case class TypeApplication(override val function: any.Type[FinalTypes], override val arguments: Seq[any.Type[FinalTypes]]) extends scala.TypeApplication[FinalTypes] with Type with Factory { - override def getSelfTypeApplication: this.type = this - } - - case class CreateList() extends scala.CreateList[FinalTypes] with Type { - } - - case class ConsListOp() extends scala.ConsListOp[FinalTypes] with Operator { - } - - case class HeadListOp() extends scala.HeadListOp[FinalTypes] with Operator { - } - - case class TailListOp() extends scala.TailListOp[FinalTypes] with Operator { - } - - case class AppendListOp() extends scala.AppendListOp[FinalTypes] with Operator { - } - - case class CreateLeaf(override val leafClass: oo.ClassReferenceType[FinalTypes]) extends scala.CreateLeaf[FinalTypes] with Type { - def getSelfCreateLeaf: this.type = this - } - - case class CreateNodeExpr(override val nodeClass: oo.ClassReferenceType[FinalTypes]) extends scala.CreateNodeExpr[FinalTypes] with Expression { - def getSelfCreateNodeExpr: this.type = this - } - - case class TestSuite(override val underlyingClass: oo.Class[FinalTypes], override val testMarkers: Seq[Boolean]) extends scala.TestSuite[FinalTypes] with Factory with Util { - def getSelfTestSuite: this.type = this - } - - case class BlockExpression(override val statements: Seq[any.Statement[FinalTypes]]) extends scala.BlockExpression[FinalTypes] with Expression { - def getSelfBlockExpression: this.type = this - } - - case class MethodReferenceExpression(override val qualifiedMethodName: Seq[any.Name[FinalTypes]]) extends scala.MethodReferenceExpression[FinalTypes] with Expression { - override def getSelfAsMethodReferenceExpression: this.type = this - } - - case class Lambda( - override val variables: Seq[(any.Name[FinalTypes], any.Type[FinalTypes])], - override val body: any.Expression[FinalTypes] - ) extends scala.Lambda[FinalTypes] with Expression { - override def getSelfLambda: this.type = this - } - - - case class DeclareFunVariable( - override val name: any.Name[FinalTypes], - override val tpe: any.Type[FinalTypes], - override val isRecursive: Boolean, - override val initializer: any.Expression[FinalTypes], - override val inExp: any.Expression[FinalTypes] - ) extends scala.DeclareFunVariable[FinalTypes] with Expression { - override def getSelfDeclareFunVariable: this.type = this - } - - - case class FunIfThenElse( - override val condition: any.Expression[FinalTypes], - override val ifBranch: any.Expression[FinalTypes], - override val elseIfBranches: Seq[(any.Expression[FinalTypes], any.Expression[FinalTypes])], - override val elseBranch: any.Expression[FinalTypes] - ) extends scala.FunIfThenElse[FinalTypes] with Expression { - override def getSelfFunIfThenElse: this.type = this - } - - - case class PatternContext(variables: Seq[any.Name[FinalTypes]]) extends scala.PatternContext[FinalTypes] with Factory with Util { - override def getSelfPatternContext: this.type = this - } - - - case class PatternVariable(name: any.Name[FinalTypes]) extends scala.PatternVariable[FinalTypes] with Expression { - override def getSelfPatternVariable: this.type = this - } - - case class ConstructorPattern( - tpe: any.Type[FinalTypes], - constructor: any.Name[FinalTypes], - arguments: Seq[any.Expression[FinalTypes]] - ) extends scala.ConstructorPattern[FinalTypes] with Expression { - override def getSelfConstructorPattern: this.type = this - } - - case class PatternMatch( - onValue: any.Expression[FinalTypes], - cases: Seq[(any.Expression[FinalTypes], any.Expression[FinalTypes])] = Seq.empty - ) extends scala.PatternMatch[FinalTypes] with Expression { - override def getSelfPatternMatch: this.type = this - } - - - - } -} diff --git a/project/build.properties b/project/build.properties index 1cfbe550..53bb739e 100644 --- a/project/build.properties +++ b/project/build.properties @@ -1 +1 @@ -sbt.version = 1.7.2 +sbt.version = 1.10.11 diff --git a/project/plugins.sbt b/project/plugins.sbt index e69de29b..2c0d0698 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -0,0 +1,2 @@ +logLevel := Level.Warn +addSbtPlugin("io.shiftleft" % "sbt-ci-release-early" % "2.1.9") diff --git a/scripts/AllEvolutions.txt b/scripts/AllEvolutions.txt index cd1f730a..80ab8dd2 100644 --- a/scripts/AllEvolutions.txt +++ b/scripts/AllEvolutions.txt @@ -2,7 +2,6 @@ D1 = M1.getModel.evolve("d1", Seq.empty, Seq(MultBy)) D2 = M1.getModel.evolve("d2", Seq(Mult), Seq.empty) D1D2 = D1.getModel.merge("d1d2", Seq.empty, Seq.empty, Seq(D2.getModel)) D3 = D1D2.getModel.evolve("d3", Seq.empty, Seq(PrettyP)) - I1 = M2.getModel.evolve("i1", Seq.empty, Seq(MultBy)) I2 = I1.getModel.evolve("i2", Seq(Power), Seq.empty) J1 = M0.getModel.evolve("j1", Seq(Sub), Seq(MultBy)) @@ -11,27 +10,32 @@ J3 = J2.getModel.evolve("j3", Seq(Neg, Divd), Seq(PrettyP) ++ J2.isOps(Seq(Neg, J4 = J3.getModel.evolve("j4", Seq.empty, Seq(Operation.asTree, Identifier)) J5 = J4.getModel.evolve("j5", Seq.empty, Seq(Equals)) J6 = J5.getModel.evolve("j6", Seq.empty, Seq(PowBy)) - K2J6 = J6.getModel.merge("k2j6", Seq.empty, Seq.empty, Seq(K2.getModel)) J7 = K2J6.getModel.evolve("j7", Seq(Inv), J2.isOps(Seq(Inv))) J8 = J7.getModel.evolve("j8", Seq.empty, Seq(Height)) - K1 = J2.getModel.evolve("k1", Seq(Power), J2.isOps(Seq(Power))) K2 = K1.getModel.evolve("k2", Seq.empty, Seq(Simplify, Collect)) - +O1 = M2.getModel.evolve("o1", Seq.empty, Seq.empty).optimize(Set((math.M0.Lit,math.M2.PrettyP))) +O1OA = O1.getModel.extend("o1oa", Seq(OA.getModel)) +O2 = O1.getModel.evolve("o2", Seq.empty, Seq.empty).optimize(Set((math.M0.Lit,math.M2.PrettyP))) +OA = M2.getModel.evolve("oa", Seq.empty, Seq.empty).optimize(Set((math.M0.Lit,math.M0.Eval))) +OD1 = M2.getModel.evolve("od1", Seq(Mult), Seq.empty) +OD2 = M2.getModel.evolve("od2", Seq(Divd), Seq.empty) +OD3 = OD2.getModel.extend("od3", Seq(OD1.getModel)) +OO1 = M2.getModel.evolve("oo1", Seq.empty, Seq(Atomic)) +OO2 = M2.getModel.evolve("oo2", Seq.empty, Seq(InsertM)) +OO3 = OO2.getModel.extend("oo3", Seq(OO1.getModel)) X1 = M0.getModel.evolve("x1", Seq(Sub), Seq(PrettyP, MultBy)) X2 = X1.getModel.evolve("x2", Seq(Times), Seq.empty) X3 = X1.getModel.evolve("x3", Seq(Divd), Seq.empty) X2X3 = X2.getModel.extend("x2x3", Seq(X3.getModel)) X4 = X2X3.getModel.evolve("x4", Seq(Neg), Seq.empty) - A1 = I1.getModel.evolve("a1", Seq(Times), Seq.empty) A1M3 = M3.getModel.extend("a1m3", Seq(A1.getModel)) A3M3I2 = A1M3.getModel.extend("a1m3i2", Seq(I2.getModel)) A3 = A1M3I2.getModel.evolve("a3", Seq(Inv), Seq.empty) C2 = Q1.getModel.evolve("c2", Seq.empty, Seq(Collect)) I2M3I1N1 = M3I1.getModel.extend("i2m3i1n1", Seq(I2.getModel, N1.getModel)) - M0 = MathDomain.baseModel.evolve("m0", Seq(Lit, Add), Seq(Eval)) M1 = M0.getModel.evolve("m1", Seq(Sub), Seq.empty) M2 = M1.getModel.evolve("m2", Seq.empty, Seq(PrettyP)) @@ -46,9 +50,8 @@ M7 = M6.getModel.evolve("m7", Seq.empty, Seq(PowBy)) M7I2 = M7.getModel.merge("m7i2", Seq.empty, M6.isOps(Seq(I2.Power)), Seq(I2.getModel)) M8 = M7I2.getModel.evolve("m8", Seq(Inv), M6.isOps(Seq(Inv))) M9 = M8.getModel.evolve("m9", Seq.empty, Seq(Height)) - N1 = M3.getModel.evolve("n1", Seq.empty, Seq(PowBy)) P1 = M2.getModel.evolve("p1", Seq(Pi, Rnd, Amortized), Seq(CountBetween, Output, ParamHeight)) Q1 = M3W1.getModel.evolve("q1", Seq(Sqrt), Seq(Operation.asTree, Identifier)) V1 = C2.getModel.evolve("v1", Seq(Inv), Seq.empty) -W1 = M1.getModel.evolve("w1", Seq(Power), Seq.empty) \ No newline at end of file +W1 = M1.getModel.evolve("w1", Seq(Power), Seq.empty) diff --git a/scripts/compare.py b/scripts/compare.py index c64d1587..e7bca421 100644 --- a/scripts/compare.py +++ b/scripts/compare.py @@ -1,7 +1,9 @@ """ - Run with Python3 to generate report of approaches that satisfy EP criteria. + Run with Python3 to generate report of approaches that satisfy EP criteria. Note + that on a windows machine, you need to use the backslash instead of the regular + slash to delineate directories. - python3 ${scriptsDir}/compare.py ${scriptsDir}/systems/SYSTEM.json >> REPORT + python3 ../../scripts/compare.py ../../scripts/systems/[EVOLUTION-JSON] >> REPORT where the JSON file has a single 'evolutions' tag, where each entry @@ -130,7 +132,7 @@ def file_structure (file): return index def strip_prefix(filename): - """Remove PREFIX-slash from the filename.""" + """Remove PREFIX plus trailing directory separator from the filename.""" if PREFIX in filename: loc = filename.index(PREFIX) reduced = filename[loc + len(PREFIX) + 1:] diff --git a/scripts/process.py b/scripts/process.py index 2aacc4b8..63af6b50 100644 --- a/scripts/process.py +++ b/scripts/process.py @@ -1,7 +1,9 @@ # Process jacoco.* output generated by the compile.py scripts -# within the directory that was result of generating systems for different approaches +# within the directory that was result of generating systems for different approaches. Note +# that on a windows machine, you need to use the backslash instead of the regular +# slash to delineate directories. # -# python3 ${scriptsDir}/process.py +# python3 ../../scripts/process.py # # The only unexpected dependency is from `scipy` because of the geometric mean method.