Some initial progress on arrays.

Problem: we need a default value for the element type of the (nested) arrays.

Author: JanBessai

language/inbetween/src/main/scala/org/combinators/ep/language/inbetween/ffi/ArraysAST.scala

@@ -4,44 +4,71 @@ import org.combinators.ep.language.inbetween.polymorphism.ParametricPolymorphism
 
 trait ArraysAST extends OperatorExpressionOpsAST with ParametricPolymorphismAST {
   object arraysOps {
-    trait CreateArray extends any.Type {
+    trait FinalTypes {
+      type Array <: arraysOps.Array
+      type CreateArrayExpression <: arraysOps.CreateArray
+    }
+
+    trait Array extends any.Type {
+      def getSelfArrayType: arraysOpsFinalTypes.Array
+    }
+
+    trait CreateArray extends any.Expression {
+      def getSelfCreateArrayExpression: arraysOpsFinalTypes.Array
+
+      def elementType: any.Type
       def dimension: any.Expression
+      def initialization: Either[any.Expression, Seq[any.Expression]]
+
+      def copy(elementType: any.Type, dimension: any.Expression, initialization: Either[any.Expression, Seq[any.Expression]]) =
+        arraysOpsFactory.createArray(elementType, dimension, initialization)
     }
 
     trait GetArrayOp extends operatorExpressions.Operator
+
     trait SetArrayOp extends operatorExpressions.Operator
+
     trait LengthArrayOp extends operatorExpressions.Operator
 
     trait Factory {
-      def createArray(dimension: any.Expression): CreateArray
 
-      def createArray(tpe: any.Type, dimensions:Seq[any.Expression], contentSpec:Option[(Seq[Int], Seq[any.Expression])]): any.Expression = {
-        contentSpec match {
+      def array(): arraysOps.Array
 
-          case Some((dims, values)) =>
-              val initializers = dimensions.zip(dims).reverse.tail.foldLeft[(any.Type,Seq[any.Expression])] ( {
-                  val arrayTpe  = polymorphismFactory.typeApplication(createArray(dimensions.last), Seq(tpe))
-                  val arrayExpr = values.grouped(dims.last).toSeq.map(subSeq =>
-                    factory.applyExpression(polymorphismFactory.typeReferenceExpression(arrayTpe), subSeq))
-                  (arrayTpe, arrayExpr)
-                }
-                ) { case ((arrayTpe, inits), (dimension, dim)) =>
+      def array(elementType: any.Type): any.Type = {
+        polymorphismFactory.typeApplication(array(), Seq(elementType))
+      }
+
+      def createArray(elementType: any.Type, dimension: any.Expression, initialization: Either[any.Expression, Seq[any.Expression]]): CreateArray
 
-                  val outerArrayTpe = polymorphismFactory.typeApplication(createArray(dimension), Seq(arrayTpe))
-                  val outerArrayExpr = inits.grouped(dim).toSeq.map(subSeq => factory.applyExpression(polymorphismFactory.typeReferenceExpression(arrayTpe), subSeq))
-                  (outerArrayTpe, outerArrayExpr)
-                }
+      def createArray(tpe: any.Type, dimensions: Seq[any.Expression], contentSpec: Option[(Seq[Int], Seq[any.Expression])]): any.Expression = {
+        contentSpec match {
+          case Some((dims, values)) =>
+            val initializers = dimensions.zip(dims).reverse.tail.foldLeft[(any.Type, Seq[any.Expression])]({
+              val arrayTpe = array(tpe)
+              val arrayExpr = values.grouped(dims.last).toSeq.map(subSeq =>
+                arraysOpsFactory.createArray(tpe, dimensions.last, Right(subSeq)))
+              (arrayTpe, arrayExpr)
+            }) { case ((arrayTpe, inits), (dimension, dim)) =>
+              val outerArrayTpe = arraysOpsFactory.array(arrayTpe)
+              val outerArrayExpr = inits.grouped(dim).toSeq.map(subSeq => 
+                arraysOpsFactory.createArray(arrayTpe, dimension, Right(subSeq)))
+              (outerArrayTpe, outerArrayExpr)
+            }
 
-              initializers._2.head
+            initializers._2.head
 
           case None =>
-            val arrayTpe = dimensions.reverse.tail.foldLeft[any.Type]( 
-              polymorphismFactory.typeApplication(createArray(dimensions.last), Seq(tpe))
-             ) { case (arrayTpe, dimension) =>
-              polymorphismFactory.typeApplication(createArray(dimension), Seq(arrayTpe))
+            val (_, arrayExpr) = dimensions.reverse.tail.foldLeft[(any.Type, arraysOps.CreateArray)]({
+              val arrayTpe = arraysOpsFactory.array(tpe)
+              val arrayExpr = arraysOpsFactory.createArray(tpe, dimensions.last, Left(null)) // TODO: null needs to be a default expression of type tpe
+              (arrayTpe, arrayExpr)
+            }) { case ((arrayTpe, innerInitializer), dimension) =>
+              val outerArrayTpe = arraysOpsFactory.array(arrayTpe)
+              val outerArrayExpr = arraysOpsFactory.createArray(arrayTpe, dimension, Left(innerInitializer))
+              (outerArrayTpe, outerArrayExpr)
             }
-            polymorphismFactory.typeReferenceExpression(arrayTpe)
-          }
+            arrayExpr
+        }
       }
 
       def getArrayOp(): GetArrayOp
@@ -56,5 +83,7 @@ trait ArraysAST extends OperatorExpressionOpsAST with ParametricPolymorphismAST
         operatorExpressionsFactory.unaryExpression(lengthArrayOp(), ar)
     }
   }
+
+  val arraysOpsFinalTypes: arraysOps.FinalTypes
   val arraysOpsFactory: arraysOps.Factory
 }