First intake for revised FFIs

Author: heineman

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

@@ -19,13 +19,17 @@ 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](Command.Performable[Context, Result, Self](self, interp))
+    liftF[Command.Performable[Context, *], Result](new Command.Performable[Context, Result] {
+      type Cmd = Self
+      val cmd = self
+      val interpreter = 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]
@@ -41,15 +45,15 @@ object Command {
   }
 
   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(())

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

@@ -71,6 +71,13 @@ 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,

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

@@ -332,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]]

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

@@ -1,7 +1,7 @@
 package org.combinators.cogen.paradigm.control
 
-import org.combinators.cogen.paradigm.{AnyParadigm, Apply, IfThenElse, Reify}
-import org.combinators.cogen.{TypeRep, Command, Understands}
+import org.combinators.cogen.paradigm.{AnyParadigm, Apply, IfThenElse, Reify, Ternary}
+import org.combinators.cogen.{Command, TypeRep, Understands}
 import Command.Generator
 
 case class PatternMatch[MethodBodyContext, PatternContext, Expression](
@@ -60,6 +60,18 @@ 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}
+import org.combinators.cogen.paradigm.{AnyParadigm, IfThenElse, Ternary}
 
 case class DeclareVariable[Name, Type, Init, Res](name: Name, tpe: Type, initialization: Init) extends Command {
   type Result = Res
@@ -55,6 +55,15 @@ 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/Arithmetic.scala

@@ -1,4 +1,4 @@
-package org.combinators.cogen.paradigm.ffi
+package org.combinators.cogen.paradigm.ffi     /*DI:LI:AI*/
 
 import org.combinators.cogen.paradigm.{AnyParadigm, Apply}
 import org.combinators.cogen.{Command, Understands}

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

@@ -1,10 +1,10 @@
-package org.combinators.cogen.paradigm.ffi
+package org.combinators.cogen.paradigm.ffi     /*DI:LI:AI*/
 
 import org.combinators.cogen.paradigm.{AnyParadigm, Apply}
 import org.combinators.cogen.{Command, Understands}
 import Command.Generator
 
-case class CreateArray[Type](elementType: Type)
+case class CreateArray[Type](elementType: Type, dimensions: Seq[Int])
 case class Get()
 case class Set()
 case class Length()
@@ -15,20 +15,20 @@ trait Arrays[Context] extends FFI {
 
   trait ArrayCapabilities {
     implicit val canCreate: Understands[Context, Apply[CreateArray[Type], Expression, Expression]]
-    def create(elemTpe: Type, contents: Seq[Expression]): Generator[Context, Expression] =
-      AnyParadigm.capability(Apply[CreateArray[Type], Expression, Expression](CreateArray(elemTpe), contents))
+    def create(elemTpe: Type, dimensions: Seq[Int], contents: Seq[Expression]): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[CreateArray[Type], Expression, Expression](CreateArray(elemTpe, dimensions), contents))
 
     implicit val canGet: Understands[Context, Apply[Get, Expression, Expression]]
-    def get(array: Expression, pos:Expression): Generator[Context, Expression] =
-      AnyParadigm.capability(Apply[Get, Expression, Expression](Get(), Seq(array, pos)))
+    def get(array: Expression, pos:Seq[Expression]): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[Get, Expression, Expression](Get(), array +: pos))
 
     implicit val canSet: Understands[Context, Apply[Set, Expression, Expression]]
-    def set(array: Expression, pos:Expression, value:Expression): Generator[Context, Expression] =
-      AnyParadigm.capability(Apply[Set, Expression, Expression](Set(), Seq(array, pos, value)))
+    def set(array: Expression, pos:Seq[Expression], value:Expression): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[Set, Expression, Expression](Set(), array +: pos :+ value))
 
     implicit val canLength: Understands[Context, Apply[Length, Expression, Expression]]
-    def length(array:Expression): Generator[Context, Expression] =
-      AnyParadigm.capability(Apply[Length, Expression, Expression](Length(), Seq(array)))
+    def length(array:Expression, dimension:Seq[Expression]): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[Length, Expression, Expression](Length(), array +: dimension))
   }
   val arrayCapabilities: ArrayCapabilities
 }

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

@@ -10,6 +10,9 @@ case class Log[T]()
 case class Sin[T]()
 case class Cos[T]()
 
+case class Max[T]()
+case class Min[T]()
+
 case class Abs[T]()
 case class Floor[T]()
 
@@ -36,6 +39,14 @@ trait RealArithmetic[Context, T] extends FFI {
     def log(base: Expression, x: Expression): Generator[Context, Expression] =
       AnyParadigm.capability(Apply[Log[T], Expression, Expression](Log[T](), Seq(base, x)))
 
+    implicit val canMax: Understands[Context, Apply[Max[T], Expression, Expression]]
+    def max(left: Expression, right: Expression): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[Max[T], Expression, Expression](Max[T](), Seq(left, right)))
+
+    implicit val canMin: Understands[Context, Apply[Min[T], Expression, Expression]]
+    def min(left: Expression, right: Expression): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[Min[T], Expression, Expression](Min[T](), Seq(left, right)))
+
     implicit val canSin: Understands[Context, Apply[Sin[T], Expression, Expression]]
     def sin(x: Expression): Generator[Context, Expression] =
       AnyParadigm.capability(Apply[Sin[T], Expression, Expression](Sin[T](), Seq(x)))

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

@@ -8,6 +8,8 @@ import scala.annotation.tailrec
 
 case class StringAppend()
 case class GetStringLength()
+case class GetCharAt()
+case class SubString()
 case class ToString[Type](sourceType: Type)
 
 trait Strings[Context] extends FFI {
@@ -18,6 +20,14 @@ trait Strings[Context] extends FFI {
     def getStringLength(expression: Expression): Generator[Context, Expression] =
       AnyParadigm.capability(Apply[GetStringLength, Expression, Expression](GetStringLength(), Seq(expression)))
 
+    implicit val canSubString: Understands[Context, Apply[SubString, Expression, Expression]]
+    def subString(expression: Expression, start:Expression, exclusiveEnd:Expression): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[SubString, Expression, Expression](SubString(), Seq(expression, start, exclusiveEnd)))
+
+    implicit val canGetCharAt: Understands[Context, Apply[GetCharAt, Expression, Expression]]
+    def getCharAt(expression: Expression, pos:Expression): Generator[Context, Expression] =
+      AnyParadigm.capability(Apply[GetCharAt, Expression, Expression](GetCharAt(), Seq(expression, pos)))
+
     implicit val canAppend: Understands[Context, Apply[StringAppend, Expression, Expression]]
     def stringAppend(xs: Expression*): Generator[Context, Expression] =
       AnyParadigm.capability(Apply[StringAppend, Expression, Expression](StringAppend(), xs))
@@ -40,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
     }
 

dynamicProgramming/src/main/scala/org/combinators/README.md

@@ -0,0 +1,7 @@
+# DP Generators that Compile:
+
+- bottomUp/twoSequences/longestCommonSubsequence (missing cases)
+- bottomUp/twoSequences/uncrossedLines (missing cases)
+- bottomUp/oneSequence/tribonacci
+- topDown/oneSequence/tribonacci
+-