info/labs/lab01/library/List.amy

+object L 
+  abstract class List
+  case class Nil() extends List
+  case class Cons(h: Int(32), t: List) extends List
+ 
+  def isEmpty(l : List): Boolean = { l match {
+    case Nil() => true
+    case _ => false 
+  }}
+
+  def length(l: List): Int(32) = { l match {
+    case Nil() => 0
+    case Cons(_, t) => 1 + length(t)
+  }}
+
+  def head(l: List): Int(32) = {
+    l match {
+      case Cons(h, _) => h
+      case Nil() => error("head(Nil)")
+    }
+  }
+
+  def headOption(l: List): O.Option = {
+    l match {
+      case Cons(h, _) => O.Some(h)
+      case Nil() => O.None()
+    }
+  }
+
+  def reverse(l: List): List = {
+    reverseAcc(l, Nil())
+  }
+
+  def reverseAcc(l: List, acc: List): List = {
+    l match {
+      case Nil() => acc
+      case Cons(h, t) => reverseAcc(t, Cons(h, acc))
+    }
+  }
+
+  def indexOf(l: List, i: Int(32)): Int(32) = {
+    l match {
+      case Nil() => -1
+      case Cons(h, t) =>
+        if (h == i) { 0 }
+        else {
+          val rec: Int(32) = indexOf(t, i);
+          if (0 <= rec) { rec + 1 }
+          else { -1 }
+        }
+    }
+  }
+
+  def range(from: Int(32), to: Int(32)): List = {
+    if (to < from) { Nil() }
+    else {
+      Cons(from, range(from + 1, to))
+    }
+  }
+
+  def sum(l: List): Int(32) = { l match {
+    case Nil() => 0
+    case Cons(h, t) => h + sum(t)
+  }}
+
+  def concat(l1: List, l2: List): List = {
+    l1 match {
+      case Nil() => l2
+      case Cons(h, t) => Cons(h, concat(t, l2))
+    }
+  }
+
+  def contains(l: List, elem: Int(32)): Boolean = { l match {
+    case Nil() =>
+      false
+    case Cons(h, t) =>
+      h == elem || contains(t, elem)
+  }}
+
+  abstract class LPair
+  case class LP(l1: List, l2: List) extends LPair
+
+  def merge(l1: List, l2: List): List = {
+    l1 match {
+      case Nil() => l2
+      case Cons(h1, t1) =>
+        l2 match {
+          case Nil() => l1
+          case Cons(h2, t2) =>
+            if (h1 <= h2) {
+              Cons(h1, merge(t1, l2))
+            } else {
+              Cons(h2, merge(l1, t2))
+            }
+        }
+    }
+  }
+
+  def split(l: List): LPair = {
+    l match {
+      case Cons(h1, Cons(h2, t)) =>
+        val rec: LPair = split(t);
+        rec match {
+          case LP(rec1, rec2) =>
+            LP(Cons(h1, rec1), Cons(h2, rec2))
+        }
+      case _ =>
+        LP(l, Nil())
+    }
+  }
+  def mergeSort(l: List): List = {
+    l match {
+      case Nil() => l
+      case Cons(h, Nil()) => l
+      case xs =>
+        split(xs) match {
+          case LP(l1, l2) =>
+            merge(mergeSort(l1), mergeSort(l2))
+        }
+    }
+  }
+  
+  def toString(l: List): String = { l match {
+    case Nil() => "List()"
+    case more => "List(" ++ toString1(more) ++ ")"
+  }}
+
+  def toString1(l : List): String = { l match {
+    case Cons(h, Nil()) => Std.intToString(h)
+    case Cons(h, t) => Std.intToString(h) ++ ", " ++ toString1(t)
+  }}
+
+  def take(l: List, n: Int(32)): List = {
+    if (n <= 0) { Nil() }
+    else { 
+      l match {
+        case Nil() => Nil()
+        case Cons(h, t) =>
+          Cons(h, take(t, n-1))
+      }
+    }
+  }
+    
+end L

info/labs/lab01/library/Option.amy

+object O 
+  abstract class Option
+  case class None() extends Option
+  case class Some(v: Int(32)) extends Option
+
+  def isdefined(o: Option): Boolean = {
+    o match {
+      case None() => false
+      case _ => true
+    }
+  }
+
+  def get(o: Option): Int(32) = {
+    o match {
+      case Some(i) => i
+      case None() => error("get(None)")
+    }
+  }
+
+  def getOrElse(o: Option, i: Int(32)): Int(32) = {
+    o match {
+      case None() => i
+      case Some(oo) => oo
+    }
+  }
+
+  def orElse(o1: Option, o2: Option): Option = {
+    o1 match {
+      case Some(_) => o1
+      case None() => o2
+    }
+  }
+
+  def toList(o: Option): L.List = {
+    o match {
+      case Some(i) => L.Cons(i, L.Nil())
+      case None() => L.Nil()
+    }
+  }
+end O

info/labs/lab01/library/Std.amy

+/** This module contains basic functionality for Amy,
+  * including stub implementations for some built-in functions
+  * (implemented in WASM or JavaScript)
+  */
+object Std 
+  def printInt(i: Int(32)): Unit = {
+    error("") // Stub implementation
+  }
+  def printString(s: String): Unit = {
+    error("") // Stub implementation
+  }
+  def printBoolean(b: Boolean): Unit = {
+    printString(booleanToString(b))
+  }
+
+  def readString(): String = {
+    error("") // Stub implementation
+  }
+
+  def readInt(): Int(32) = {
+    error("") // Stub implementation
+  }
+
+  def intToString(i: Int(32)): String = {
+    if (i < 0) {
+      "-" ++ intToString(-i)
+    } else {
+      val rem: Int(32) = i % 10;
+      val div: Int(32) = i / 10;
+      if (div == 0) { digitToString(rem) }
+      else { intToString(div) ++ digitToString(rem) }
+    }
+  }
+  def digitToString(i: Int(32)): String = {
+    error("") // Stub implementation
+  }
+  def booleanToString(b: Boolean): String = {
+    if (b) { "true" } else { "false" }
+  }
+end Std

info/labs/lab01/project/build.properties

+sbt.version=1.10.7

info/labs/lab01/project/plugins.sbt

+addSbtPlugin("com.lightbend.sbt" % "sbt-proguard" % "0.3.0")
+
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.2.0")
\ No newline at end of file

info/labs/lab01/src/amyc/Main.scala

+package amyc
+
+import utils._
+import interpreter.Interpreter
+
+import java.io.File
+
+object Main {
+  private def parseArgs(args: Array[String]): Context = {
+    var ctx = Context(new Reporter, Nil)
+    args foreach {
+      case "--interpret"   => ctx = ctx.copy(interpret = true)
+      case "--help"        => ctx = ctx.copy(help = true)
+      case "--type-check"  => ctx = ctx.copy(typeCheck = true)
+      case file            => ctx = ctx.copy(files = ctx.files :+ file)
+    }
+    ctx
+  }
+
+  def main(args: Array[String]): Unit = {
+    val ctx = parseArgs(args)
+    val pipelineInterpret = Frontend.pipeline.andThen(Interpreter)
+
+    if ctx.help then
+      println("Usage: amyc [ --interpret | --type-check ] file1.amy file2.amy ...")
+      sys.exit(0)
+    val files = ctx.files.map(new File(_))
+
+    try {
+      if (files.isEmpty) {
+        ctx.reporter.fatal("No input files")
+      }
+      files.find(!_.exists()).foreach { f =>
+        ctx.reporter.fatal(s"File not found: ${f.getName}")
+      }
+      if ctx.interpret then
+        pipelineInterpret.run(ctx)(files)
+      else if ctx.typeCheck then
+        Frontend.pipeline.run(ctx)(files)
+        println("Type checking successful!")
+      else
+        ctx.reporter.fatal("No action specified")
+      ctx.reporter.terminateIfErrors()
+    } catch {
+      case AmycFatalError(_) =>
+        sys.exit(1)
+    }
+  }
+}
\ No newline at end of file

labs/labs01_material/SymbolicTreeModule.scala → info/labs/lab01/src/amyc/ast/TreeModule.scala

@@ -2,16 +2,38 @@ package amyc.ast
 
 import amyc.utils.Positioned
 
-// Definitions of symbolic Amy syntax trees
-trait TreeModule {
+/* A polymorphic module containing definitions of Amy trees.
+ *
+ * This trait represents either nominal trees (where names have not been resolved)
+ * or symbolic trees (where names/qualified names) have been resolved to unique identifiers.
+ * This is done by having two type fields within the module,
+ * which will be instantiated differently by the two different modules.
+ *
+ */
+
+trait TreeModule { self =>
+  /* Represents the type for the name for this tree module.
+   * (It will be either a plain string, or a unique symbol)
+   */
+  type Name
+
+  // Represents a name within an module
+  type QualifiedName
+
+  // A printer that knows how to print trees in this module.
+  // The modules will instantiate it as appropriate
+  val printer: Printer { val treeModule: self.type }
+
   // Common ancestor for all trees
-  trait Tree extends Positioned
+  trait Tree extends Positioned {
+    override def toString: String = printer(this)
+  }
 
   // Expressions
   trait Expr extends Tree
 
   // Variables
-  case class Variable(name: Identifier) extends Expr
+  case class Variable(name: Name) extends Expr
 
   // Literals
   trait Literal[+T] extends Expr { val value: T }
@@ -37,8 +59,8 @@ trait TreeModule {
   case class Not(e: Expr) extends Expr
   case class Neg(e: Expr) extends Expr
 
-  // Function/ type constructor call
-  case class Call(qname: Identifier, args: List[Expr]) extends Expr
+  // Function/constructor call
+  case class Call(qname: QualifiedName, args: List[Expr]) extends Expr
   // The ; operator
   case class Sequence(e1: Expr, e2: Expr) extends Expr
   // Local variable definition
@@ -57,28 +79,38 @@ trait TreeModule {
 
   abstract class Pattern extends Tree
   case class WildcardPattern() extends Pattern // _
-  case class IdPattern(name: Identifier) extends Pattern // x
+  case class IdPattern(name: Name) extends Pattern // x
   case class LiteralPattern[+T](lit: Literal[T]) extends Pattern // 42, true
-  case class CaseClassPattern(constr: Identifier, args: List[Pattern]) extends Pattern // C(arg1, arg2)
+  case class CaseClassPattern(constr: QualifiedName, args: List[Pattern]) extends Pattern // C(arg1, arg2)
 
   // Definitions
-  trait Definition extends Tree { val name: Identifier }
-  case class ModuleDef(name: Identifier, defs: List[ClassOrFunDef], optExpr: Option[Expr]) extends Definition
+  trait Definition extends Tree { val name: Name }
+  case class ModuleDef(name: Name, defs: List[ClassOrFunDef], optExpr: Option[Expr]) extends Definition
   trait ClassOrFunDef extends Definition
-  case class FunDef(name: Identifier, params: List[ParamDef], retType: TypeTree, body: Expr) extends ClassOrFunDef {
+  case class FunDef(name: Name, params: List[ParamDef], retType: TypeTree, body: Expr) extends ClassOrFunDef {
     def paramNames = params.map(_.name)
   }
-  case class AbstractClassDef(name: Identifier) extends ClassOrFunDef
-  case class CaseClassDef(name: Identifier, fields: List[TypeTree], parent: Identifier) extends ClassOrFunDef
-  case class ParamDef(name: Identifier, tpe: TypeTree) extends Definition
+  case class AbstractClassDef(name: Name) extends ClassOrFunDef
+  case class CaseClassDef(name: Name, fields: List[TypeTree], parent: Name) extends ClassOrFunDef
+  case class ParamDef(name: Name, tt: TypeTree) extends Definition
 
   // Types
   trait Type
-  case object IntType extends Type 
-  case object BooleanType extends Type
-  case object StringType extends Type
-  case object UnitType extends Type
-  case class ClassType(qname: Identifier) extends Type
+  case object IntType extends Type {
+    override def toString: String = "Int"
+  }
+  case object BooleanType extends Type {
+    override def toString: String = "Boolean"
+  }
+  case object StringType extends Type {
+    override def toString: String = "String"
+  }
+  case object UnitType extends Type {
+    override def toString: String = "Unit"
+  }
+  case class ClassType(qname: QualifiedName) extends Type {
+    override def toString: String = printer.printQName(qname)(false).print
+  }
 
   // A wrapper for types that is also a Tree (i.e. has a position)
   case class TypeTree(tpe: Type) extends Tree
@@ -87,5 +119,24 @@ trait TreeModule {
   case class Program(modules: List[ModuleDef]) extends Tree
 }
 
-// Identifiers represent unique names in Amy
-class Identifier private(val name: String)
+/* A module containing trees where the names have not been resolved.
+ * Instantiates Name to String and QualifiedName to a pair of Strings
+ * representing (module, name) (where module is optional)
+ */
+object NominalTreeModule extends TreeModule {
+  type Name = String
+  case class QualifiedName(module: Option[String], name: String) {
+    override def toString: String = printer.printQName(this)(false).print
+  }
+  val printer = NominalPrinter
+}
+
+/* A module containing trees where the names have been resolved to unique identifiers.
+ * Both Name and ModuleName are instantiated to Identifier.
+ */
+object SymbolicTreeModule extends TreeModule {
+  type Name = Identifier
+  type QualifiedName = Identifier
+  val printer = SymbolicPrinter
+}
+

info/labs/lab01/src/amyc/interpreter/Interpreter.scala

+package amyc
+package interpreter
+
+import utils._
+import ast.SymbolicTreeModule._
+import ast.Identifier
+import analyzer.SymbolTable
+
+// An interpreter for Amy programs, implemented in Scala
+object Interpreter extends Pipeline[(Program, SymbolTable), Unit] {
+
+  // A class that represents a value computed by interpreting an expression
+  abstract class Value {
+    def asInt: Int = this.asInstanceOf[IntValue].i
+    def asBoolean: Boolean = this.asInstanceOf[BooleanValue].b
+    def asString: String = this.asInstanceOf[StringValue].s
+
+    override def toString: String = this match {
+      case IntValue(i) => i.toString
+      case BooleanValue(b) => b.toString
+      case StringValue(s) => s
+      case UnitValue => "()"
+      case CaseClassValue(constructor, args) =>
+        constructor.name + "(" + args.map(_.toString).mkString(", ") + ")"
+    }
+  }
+  case class IntValue(i: Int) extends Value
+  case class BooleanValue(b: Boolean) extends Value
+  case class StringValue(s: String) extends Value
+  case object UnitValue extends Value
+  case class CaseClassValue(constructor: Identifier, args: List[Value]) extends Value
+
+  def run(ctx: Context)(v: (Program, SymbolTable)): Unit = {
+    val (program, table) = v
+
+    // These built-in functions do not have an Amy implementation in the program,
+    // instead their implementation is encoded in this map
+    val builtIns: Map[(String, String), (List[Value]) => Value] = Map(
+      ("Std", "printInt")    -> { args => println(args.head.asInt); UnitValue },
+      ("Std", "printString") -> { args => println(args.head.asString); UnitValue },
+      ("Std", "readString")  -> { args => StringValue(scala.io.StdIn.readLine()) },
+      ("Std", "readInt")     -> { args =>
+        val input = scala.io.StdIn.readLine()
+        try {
+          IntValue(input.toInt)
+        } catch {
+          case ne: NumberFormatException =>
+            ctx.reporter.fatal(s"""Could not parse "$input" to Int""")
+        }
+      },
+      ("Std", "intToString")   -> { args => StringValue(args.head.asInt.toString) },
+      ("Std", "digitToString") -> { args => StringValue(args.head.asInt.toString) }
+    )
+
+    // Utility functions to interface with the symbol table.
+    def isConstructor(name: Identifier) = table.getConstructor(name).isDefined
+    def findFunctionOwner(functionName: Identifier) = table.getFunction(functionName).get.owner.name
+    def findFunction(owner: String, name: String) = {
+      program.modules.find(_.name.name == owner).get.defs.collectFirst {
+        case fd@FunDef(fn, _, _, _) if fn.name == name => fd
+      }.get
+    }
+
+    // Interprets a function, using evaluations for local variables contained in 'locals'
+ 
+    // TODO: Complete all missing cases. Look at the given ones for guidance. 
+    def interpret(expr: Expr)(implicit locals: Map[Identifier, Value]): Value = {
+      expr match {
+        case Variable(name) =>
+            ???
+        case IntLiteral(i) =>
+            ???
+        case BooleanLiteral(b) =>
+            ???
+        case StringLiteral(s) =>
+            ???
+        case UnitLiteral() =>
+            ???
+        case Plus(lhs, rhs) =>
+          IntValue(interpret(lhs).asInt + interpret(rhs).asInt)
+        case Minus(lhs, rhs) =>
+            ???
+        case Times(lhs, rhs) =>
+            ???
+        case Div(lhs, rhs) =>
+            ???
+        case Mod(lhs, rhs) =>
+            ???
+        case LessThan(lhs, rhs) =>
+            ???
+        case LessEquals(lhs, rhs) =>
+            ???
+        case And(lhs, rhs) =>
+            ???
+        case Or(lhs, rhs) =>
+            ???
+        case Equals(lhs, rhs) =>
+            ??? // Hint: Take care to implement Amy equality semantics
+        case Concat(lhs, rhs) =>
+            ???
+        case Not(e) =>
+            ???
+        case Neg(e) =>
+            ???
+        case Call(qname, args) =>
+            ???
+            // Hint: Check if it is a call to a constructor first,
+            //       then if it is a built-in function (otherwise it is a normal function).
+            //       Use the helper methods provided above to retrieve information from the symbol table.
+            //       Think how locals should be modified.
+        case Sequence(e1, e2) =>
+            ???
+        case Let(df, value, body) =>
+            ???
+        case Ite(cond, thenn, elze) =>
+            ???
+        case Match(scrut, cases) =>
+            ???
+            // Hint: We give you a skeleton to implement pattern matching
+            //       and the main body of the implementation
+          val evS = interpret(scrut)
+
+          // None = pattern does not match
+            // Returns a list of pairs id -> value,
+            // where id has been bound to value within the pattern.
+            // Returns None when the pattern fails to match.
+            // Note: Only works on well typed patterns (which have been ensured by the type checker).
+          def matchesPattern(v: Value, pat: Pattern): Option[List[(Identifier, Value)]] = {
+            ((v, pat): @unchecked) match {
+              case (_, WildcardPattern()) => 
+                  ???
+              case (_, IdPattern(name)) => 
+                  ???
+              case (IntValue(i1), LiteralPattern(IntLiteral(i2))) =>
+                  ???
+              case (BooleanValue(b1), LiteralPattern(BooleanLiteral(b2))) =>
+                  ???
+              case (StringValue(_), LiteralPattern(StringLiteral(_))) =>
+                  ???
+              case (UnitValue, LiteralPattern(UnitLiteral())) =>
+                  ???
+              case (CaseClassValue(con1, realArgs), CaseClassPattern(con2, formalArgs)) =>
+                  ???
+            }
+          }
+          // Main "loop" of the implementation: Go through every case,
+          // check if the pattern matches, and if so return the evaluation of the case expression
+          cases.to(LazyList).map(matchCase => 
+            val MatchCase(pat, rhs) = matchCase
+            (rhs, matchesPattern(evS, pat))
+          ).find(_._2.isDefined) match {
+            case Some((rhs, Some(moreLocals))) =>
+              interpret(rhs)(locals ++ moreLocals)
+            case _ =>
+              // No case matched
+              ctx.reporter.fatal(s"Match error: ${evS.toString}@${scrut.position}")
+          }
+
+        case Error(msg) =>
+            ???
+      }
+    }
+
+    for {
+      m <- program.modules
+      e <- m.optExpr
+    } {
+      interpret(e)(Map())
+    }
+  }
+}

info/labs/lab01/test/resources/execution/failing/BasicError.grading.amy

+object BasicError
+
+	def throwError(msg: String): Unit = {
+		error(msg)
+	}
+
+	throwError("basic error test")
+end BasicError

info/labs/lab01/test/resources/execution/failing/Division.grading.amy

+object Division
+  1/0
+end Division

info/labs/lab01/test/resources/execution/failing/Locals.grading.amy

+object Locals
+  def foo(i: Int(32)): Int(32) = {
+    val i: Int(32) = 0;
+    if (i == 0) { error("") }
+    else { 0 }
+  }
+
+  foo(1)
+end Locals

info/labs/lab01/test/resources/execution/failing/MatchError1.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar() extends Foo
+  case class Baz() extends Foo
+
+  Bar() match { case Baz() => () }
+end MatchError

info/labs/lab01/test/resources/execution/failing/MatchError2.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar() extends Foo
+  case class Baz(i: Int(32)) extends Foo
+
+  Baz(1) match { case Baz(2) => () }
+end MatchError

info/labs/lab01/test/resources/execution/failing/MatchError3.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar() extends Foo
+  case class Baz(f: Foo) extends Foo
+
+  Baz(Bar()) match { case Baz(Baz(_)) => () }
+end MatchError

info/labs/lab01/test/resources/execution/failing/MatchError4.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar(s: String) extends Foo
+
+  Bar("foo") match { case Bar("foo") => () }
+end MatchError

info/labs/lab01/test/resources/execution/failing/MinimalError.amy

+object MinimalError
+	error("")
+end MinimalError

info/labs/lab01/test/resources/execution/failing/ShortCircuit.grading.amy

+object ShortCircuit
+  false || error("")
+end ShortCircuit

info/labs/lab01/test/resources/execution/outputs/Arithmetic.grading.txt

+0
+1
+1024
+27
+10
+1
+2
+222

info/labs/lab01/test/resources/execution/outputs/BasicArithmetic.grading.txt

+3
+6
+4
+8
+2
+1
+0
+0
+-1
+-1
+1
+-1
+test finished
\ No newline at end of file

info/labs/lab01/test/resources/execution/outputs/BasicBranching.grading.txt

+correct
+not correct
+not correct
+correct
+test finished
\ No newline at end of file