ScaIR wow

Author: PapyChacal

src/main/scala/uk/ac/ed/dal/structtensor/Main.scala

@@ -11,7 +11,7 @@ import java.io.File
 import scopt.OParser
 
 object Main {
-  def main(args: Array[String]) = {
+  def main(args: Array[String]): Unit = {
   import Optimizer._
   import Utils._
 
@@ -112,37 +112,49 @@ object Main {
           .toSeq
           .filter(_.nonEmpty)
           .filterNot(_.startsWith("#"))
+
+        // Specify names of symbols
         val (symbols_lines, symbols_index) =
           lineSeqInit.zipWithIndex.filter(_._1.startsWith("symbols:")).unzip
+
+        // Specify names of tensors expected to be output
         val (outputs_lines, outputs_index) =
           lineSeqInit.zipWithIndex.filter(_._1.startsWith("outputs:")).unzip
+
+        // Specify names of iterators
         val (iters_lines, iters_index) =
           lineSeqInit.zipWithIndex.filter(_._1.startsWith("iters:")).unzip
+        // parsed symbols names
         val symbols = symbols_lines
           .map(e => e.slice(8, e.length))
           .flatMap(_.split(",").map(_.trim).toSeq)
           .map(Variable(_))
+        // parsed outputs names
         val outputs_names = outputs_lines
           .map(e => e.slice(8, e.length))
           .flatMap(_.split(",").map(_.trim).toSeq)
+        // parsed iterators names and vars
         val iters_map = iters_lines
           .map(e => e.slice(6, e.length))
           .flatMap(_.split(";").map(_.trim).toSeq)
           .map(iter_str =>
             fastparse.parse(iter_str, Parser.iterators(_)).get.value
           )
           .toMap
+        // Remaining input lines AKA the program + compression hatches
         val lineSeq = lineSeqInit.zipWithIndex
           .filterNot(x =>
             symbols_index.contains(x._2) ||
               outputs_index.contains(x._2) ||
               iters_index.contains(x._2)
           )
           .map(_._1)
+        // Manual arbitrary access computation danger zone start
         val preprocess_start_index = lineSeq.indexOf("@preprocess_start")
         val preprocess_end_index = lineSeq.indexOf("@preprocess_end")
         val preprocess_lines =
           lineSeq.slice(preprocess_start_index + 1, preprocess_end_index)
+        // Remaining input lines AKA JUST the program 
         val computation_lines = lineSeq.slice(
           0,
           preprocess_start_index
@@ -154,19 +166,29 @@ object Main {
             res.head
           })
           .toSeq
+        // Danger zone end?
+
+        // Program parsed as bunch of rules
         val parsedComputation = computation_lines
           .map(line => {
             val Parsed.Success(res, _) = parse(line, parser(_))
             res.head
           })
           .toSeq
+        
+        // cOOKED COMPRESSION RULES
+        // Ignore if ignoring manual compression hatch
         val (
           all_tensors_preprocess,
           tensorComputations_preprocess,
           dimInfo_preprocess,
           uniqueSets_preprocess,
           redundancyMaps_preprocess
         ) = convertRules(parsedPreprocess)
+
+        // Tensor information extracted from the computation rules, before
+        // any inference.
+        // Probably what we want to ScaIR out!
         val (
           all_tensors_computation,
           tensorComputations_computation,
@@ -184,7 +206,13 @@ object Main {
           symbols,
           outputs_names
         )
+        val ScaIR = false
 
+        if (ScaIR) {
+          // wow
+          return ()
+        } 
+        
         val (newUS, newRM, newCC, ccRuleSeq, rcRuleSeq) =
           tensorComputations_computation.foldLeft(
             (