Cleanup: remove old features, remove ternary, fix some scala 3 syntax, fix lambdas

Author: JanBessai

cogen/src/main/scala/org/combinators/cogen/Command.scala

@@ -21,8 +21,8 @@ trait Command {
 
     liftF[Command.Performable[Context, *], Result](new Command.Performable[Context, Result] {
       type Cmd = Self
-      val cmd = self
-      val interpreter = interp
+      val cmd: Self = self
+      val interpreter: Understands[Context, Self] = interp
     })
   }
 }

cogen/src/main/scala/org/combinators/cogen/paradigm/AnyParadigm.scala

@@ -71,13 +71,6 @@ case class ResolveImport[Import, T](forElem: T) extends Command {
   type Result = Option[Import]
 }
 
-case class Ternary[Expression, R](
-  condition: Expression,
-  trueExpression: Expression,
-  falseExpression: Expression) extends Command {
-  type Result = R
-}
-
 case class IfThenElse[Expression, MandatoryBlock, Block, R](
     condition: Expression,
     ifBranch: MandatoryBlock,
@@ -186,10 +179,6 @@ trait AnyParadigm {
     implicit val canDebugInMethodBody: Understands[MethodBodyContext, Debug]
     def debug(tag:String = ""): Generator[MethodBodyContext, Unit] =
       AnyParadigm.capability(Debug(tag))
-
-    implicit val canOutputToConsole: Understands[MethodBodyContext, OutputToConsole[Expression]]
-    def output(expr:Expression): Generator[MethodBodyContext, Unit] =
-      AnyParadigm.capability(OutputToConsole[Expression](expr))
 
     implicit val canAddImportInMethodBody: Understands[MethodBodyContext, AddImport[Import]]
     def addImport(imp: Import): Generator[MethodBodyContext, Unit] =
@@ -252,8 +241,8 @@ object AnyParadigm {
 
   def capability[Ctxt, R, Cmd <: Command.WithResult[R]]
     (cmd: Cmd)
-    (implicit interp: Understands[Ctxt, Cmd]): Generator[Ctxt, R] = {
-    cmd.interpret[Ctxt, Cmd](interp)
+    (using interp: Understands[Ctxt, Cmd]): Generator[Ctxt, R] = {
+    cmd.interpret[Ctxt, Cmd](using interp)
   }
 
   object syntax {

cogen/src/main/scala/org/combinators/cogen/paradigm/ObjectOriented.scala

@@ -136,11 +136,6 @@ trait ObjectOriented {
     def addImplemented(interface: Type): Generator[ClassContext, Unit] =
       AnyParadigm.capability(AddImplemented(interface))
 
-    // FIRST REMOVE CAPABILITY
-    implicit val canRemoveMethodFromClass: Understands[ClassContext, RemoveMethod[Type, Name]]
-    def removeMethod(interface: Type, name:Name): Generator[ClassContext, Unit] =
-      AnyParadigm.capability(RemoveMethod(interface, name))
-
     implicit val canAddFieldInClass: Understands[ClassContext, AddField[Name, Type, Expression]]
     def addField(name: Name, tpe: Type, init:Option[Expression] = Option.empty): Generator[ClassContext, Unit] =
       AnyParadigm.capability(AddField[Name, Type, Expression](name, tpe, initializer = init))
@@ -332,7 +327,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]]

cogen/src/main/scala/org/combinators/cogen/paradigm/ParametricPolymorphism.scala

@@ -28,7 +28,7 @@ trait ParametricPolymorphism {
       AnyParadigm.capability(AddTypeParameter[Name, TypeParameterContext](name, spec))
 
     implicit val canGetTypeArgumentsInMethod: Understands[MethodBodyContext, GetTypeArguments[Type]]
-    def getTypeArguments(): Generator[MethodBodyContext, Seq[Type]] =
+    def getTypeArguments: Generator[MethodBodyContext, Seq[Type]] =
       AnyParadigm.capability(GetTypeArguments[Type]())
 
     implicit val canApplyTypeInMethod: Understands[MethodBodyContext, Apply[Type, Type, Type]]

cogen/src/main/scala/org/combinators/cogen/paradigm/control/Functional.scala

@@ -1,6 +1,6 @@
 package org.combinators.cogen.paradigm.control
 
-import org.combinators.cogen.paradigm.{AnyParadigm, Apply, IfThenElse, Reify, Ternary}
+import org.combinators.cogen.paradigm.{AnyParadigm, Apply, IfThenElse, Reify}
 import org.combinators.cogen.{Command, TypeRep, Understands}
 import Command.Generator
 
@@ -60,18 +60,6 @@ trait Functional[Context] extends Lambdas[Context] {
           elseBlock
         ))
 
-    implicit val canTernary: Understands[Context, Ternary[Expression, Expression]]
-    def ternary(
-        cond: Expression,
-        trueExpression: Expression,
-        falseExpression: Expression): Generator[Context, Expression] =
-      AnyParadigm.capability(
-        Ternary[Expression, Expression](
-          cond,
-          trueExpression,
-          falseExpression)
-      )
-
     implicit val canPatternMatch: Understands[Context, PatternMatch[Context, PatternContext, Expression]]
     def patternMatch(
         onValue: Expression,

cogen/src/main/scala/org/combinators/cogen/paradigm/control/Imperative.scala

@@ -3,7 +3,7 @@ package org.combinators.cogen.paradigm.control
 import org.combinators.cogen.{Command, Understands}
 import Command.Generator
 
-import org.combinators.cogen.paradigm.{AnyParadigm, IfThenElse, Ternary}
+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
@@ -55,15 +55,6 @@ trait Imperative[Context] {
         condition, ifBranch, elseIfs, elseBranch
       ))
 
-    implicit val canTernary: Understands[Context, Ternary[Expression, Expression]]
-    def ternary(
-        condition: Expression,
-        trueExpression: Expression,
-        falseExpression: Expression): Generator[Context, Expression] =
-      AnyParadigm.capability(Ternary[Expression, Expression](
-        condition, trueExpression, falseExpression
-      ))
-
     implicit val canWhile: Understands[Context, While[Context, Expression, Statement]]
     def whileLoop(condition: Expression, block: Generator[Context, Unit]): Generator[Context, Statement] =
       AnyParadigm.capability(While[Context, Expression, Statement](condition, block))

cogen/src/main/scala/org/combinators/cogen/paradigm/ffi/Strings.scala

@@ -50,7 +50,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
     }
 

language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/any/AnyParadigm.scala

@@ -72,11 +72,6 @@ trait AnyParadigm[A, S](val ast: AnyAST & A, val syntax: AbstractSyntax.Abstract
         (context, ())
       }
     }
-    implicit val canOutputToConsole: Understands[MethodBodyContext, OutputToConsole[syntax.Expression]] = new Understands[MethodBodyContext, OutputToConsole[syntax.Expression]] {
-      def perform(context: MethodBodyContext, command: OutputToConsole[syntax.Expression]): (MethodBodyContext, Unit) = {
-        (context, ())
-      }
-    }
 
     implicit val canAddImportInMethodBody: Understands[MethodBodyContext, AddImport[syntax.Import]] = new Understands[MethodBodyContext, AddImport[syntax.Import]] {
       def perform(context: MethodBodyContext, command: AddImport[syntax.Import]): (MethodBodyContext, Unit) = {

language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/functional/control/Functional.scala

@@ -3,7 +3,7 @@ package org.combinators.ep.language.inbetween.functional.control
 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, Ternary}
+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
@@ -44,13 +44,6 @@ trait Functional[AST <: FunctionalControlAST, B](val _base: AnyParadigm.WithAST[
             (resContext, functionalControlFactory.declareFunVariable(command.name, command.tpe, isRecursive = true, initExp, inExp))
           }
         }
-
-      implicit val canTernary: Understands[any.Method, Ternary[any.Expression, any.Expression]] =
-        new Understands[any.Method, Ternary[any.Expression, any.Expression]] {
-          override def perform(context: any.Method, command: Ternary[any.Expression, any.Expression]): (any.Method, any.Expression) = {
-            (context, functionalControlFactory.funIfThenElse(command.condition, command.trueExpression, Seq.empty, command.falseExpression))
-          }
-        }
 
       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]] {

language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/imperative/Imperative.scala

@@ -1,6 +1,6 @@
 package org.combinators.ep.language.inbetween.imperative   /*DI:LI:AI*/
 
-import org.combinators.cogen.paradigm.{IfThenElse, control, Ternary}
+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}
@@ -44,21 +44,7 @@ trait Imperative[AST <: ImperativeAST, B](val _base: AnyParadigm.WithAST[AST] &
             (context, liftStmt)
           }
         }
-      implicit val canTernary: Understands[Ctxt, Ternary[any.Expression, any.Expression]] =
-          new Understands[Ctxt, Ternary[any.Expression, any.Expression]] {
-            /** Returns the updated context and the result of the command. */
-            override def perform(context: Ctxt, command: Ternary[any.Expression, any.Expression]): (Ctxt, any.Expression) = {
-              def contextWithoutMethodBody(context: Ctxt) =
-                context.copy(statements = Seq.empty)
-
-              val (condCtxt, cond) = Command.runGenerator(Command.lift[Ctxt, any.Expression](command.condition), contextWithoutMethodBody(context))
-              val (trueCtxt, trueExpr) = Command.runGenerator(Command.lift[Ctxt, any.Expression](command.trueExpression), contextWithoutMethodBody(condCtxt))
-              val (falseCtxt, falseExpr) = Command.runGenerator(Command.lift[Ctxt, any.Expression](command.falseExpression), contextWithoutMethodBody(trueCtxt))
-
-              val ternaryExpr = imperativeFactory.tertiary(cond, trueExpr, falseExpr)
-              (context.copy(statements = context.statements), ternaryExpr)
-            }
-          }
+ 
       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. */