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

+42
\ No newline at end of file

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

+This side effect should only happen once!
+yes

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

+42
+42
\ No newline at end of file

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

+1
+2
+1
+2
+1
+2
+1
+2
+1
+2
+1
+2
+1
+2
+Left
+Right
+SLeft
+SRight
+CLeft
+CRight
\ No newline at end of file

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

+Hello World!
+Hello World again!
\ No newline at end of file

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

+9
+List(-5, -1, 0, 5, 10)

info/labs/lab01/test/resources/execution/passing/Arithmetic.grading.amy

+object Arithmetic
+  def pow(b: Int(32), e: Int(32)): Int(32) = {
+    if (e == 0) { 1 }
+    else {
+      if (e % 2 == 0) {
+        val rec: Int(32) = pow(b, e/2);
+        rec * rec
+      } else {
+        b * pow(b, e - 1)
+      }
+    }
+  }
+
+  def gcd(a: Int(32), b: Int(32)): Int(32) = {
+    if (a == 0 || b == 0) {
+      a + b
+    } else {
+      if (a < b) {
+        gcd(a, b % a)
+      } else {
+        gcd(a % b, b)
+      }
+    }
+  }
+
+  Std.printInt(pow(0, 10));
+  Std.printInt(pow(1, 5));
+  Std.printInt(pow(2, 10));
+  Std.printInt(pow(3, 3));
+  Std.printInt(gcd(0, 10));
+  Std.printInt(gcd(17, 99)); // 1
+  Std.printInt(gcd(16, 46)); // 2
+  Std.printInt(gcd(222, 888)) // 222
+end Arithmetic
\ No newline at end of file

info/labs/lab01/test/resources/execution/passing/BasicArithmetic.grading.amy

+object BasicArithmetic
+
+	def plus(a: Int(32), b: Int(32)): Int(32) = {
+		a + b
+	}
+
+	def minus(a: Int(32), b: Int(32)): Int(32) = {
+		a - b
+	}
+
+	def mul(a: Int(32), b: Int(32)): Int(32) = {
+		a * b
+	}
+
+	def mod(a: Int(32), b: Int(32)): Int(32) = {
+		a % b
+	}
+
+	def div(a: Int(32), b: Int(32)): Int(32) = {
+		a / b
+	}
+
+	val a: Int(32) = 1;
+	val b: Int(32) = 2;
+
+	Std.printString(Std.intToString(plus(a, b)));
+	Std.printString(Std.intToString(mul(plus(a, b), b)));
+	Std.printString(Std.intToString(minus(mul(plus(a, b), b), b)));
+	Std.printString(Std.intToString(mul(minus(mul(plus(a, b), b), b), b)));
+
+	Std.printString(Std.intToString(div(4, 2)));
+	Std.printString(Std.intToString(div(3, 2)));
+	Std.printString(Std.intToString(div(1, 2)));
+	Std.printString(Std.intToString(div(-1, 2)));
+	Std.printString(Std.intToString(div(-2, 2)));
+	Std.printString(Std.intToString(div(-3, 2)));
+
+	Std.printString(Std.intToString(mod(5, 2)));
+	Std.printString(Std.intToString(mod(-5, 2)));
+
+	Std.printString("test finished")
+end BasicArithmetic

info/labs/lab01/test/resources/execution/passing/BasicBranching.grading.amy

+object BasicBranching
+
+	def less(a: Int(32), b: Int(32)): Boolean = {
+		a < b
+	}
+
+	def lessOrEqual(a: Int(32), b: Int(32)): Boolean = {
+		a <= b
+	}
+
+	def test1(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(a, b)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	def test2(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(a, 1)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	def test3(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(b, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	def test4(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;		
+		if(lessOrEqual(a, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}		
+	}
+
+	def test(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(a, b)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		};
+
+		if(less(a, 1)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		};
+
+		if(less(b, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		};
+
+		if(lessOrEqual(a, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	test();
+
+	Std.printString("test finished")
+end BasicBranching

info/labs/lab01/test/resources/execution/passing/BasicConditions.grading.amy

+object BasicConditions
+
+	def neverTrigger(): Boolean = {
+		Std.printString("should not happen");
+		true
+	}
+
+	val c1: Boolean = true || neverTrigger();
+	val c2: Boolean = false && neverTrigger();
+
+	Std.printString("test finished")
+end BasicConditions
\ No newline at end of file

info/labs/lab01/test/resources/execution/passing/BasicPatternMatching.grading.amy

+object BasicPatternMatching
+  abstract class Letter
+  case class A() extends Letter
+  case class APrim(i: Int(32)) extends Letter
+  case class B() extends Letter
+  case class BPrim(i: Int(32)) extends Letter
+ 
+  def isRegularLetter(l: Letter): Boolean = { 
+  	l match {
+		case A() => true
+		case B() => true
+		case APrim(_) => false 
+		case BPrim(_) => false
+	}
+  }
+
+  def getPrimNumber(l: Letter): Int(32) = {
+  	!isRegularLetter(l) match {
+  		case false => 42
+  		case true => l match {
+  			case APrim(i) => i
+  			case BPrim(i) => i
+  		}
+  	}
+  }
+
+  def isPrimLetter(l: Letter): String = {
+    getPrimNumber(l) match {
+      case 42 => "not prim"
+      case _ => "prim"
+    }
+  }
+
+
+  val a: Letter = A();
+  val ap: Letter = APrim(2);
+  val b: Letter = B();
+  val bp: Letter = BPrim(3);
+  
+  Std.printString(Std.intToString(getPrimNumber(a)));
+  Std.printString(Std.intToString(getPrimNumber(b)));
+  Std.printString(Std.intToString(getPrimNumber(ap)));
+  Std.printString(Std.intToString(getPrimNumber(bp)));
+
+  Std.printString(isPrimLetter(ap));
+  Std.printString(isPrimLetter(bp));
+  Std.printString(isPrimLetter(a));
+  Std.printString(isPrimLetter(b));
+
+  Std.printString("test finished")
+end BasicPatternMatching
\ No newline at end of file

info/labs/lab01/test/resources/execution/passing/EmptyObject.amy

+object EmptyObject
+
+end EmptyObject
\ No newline at end of file

info/labs/lab01/test/resources/execution/passing/Equality.grading.amy

+object Equality
+  abstract class Foo
+  case class Foo1() extends Foo
+  case class Foo2() extends Foo
+
+  Std.printString(Std.booleanToString(0 == 0));
+  Std.printString(Std.booleanToString(0 == 1));
+  Std.printString(Std.booleanToString(true == true));
+  Std.printString(Std.booleanToString(true == false));
+  Std.printString(Std.booleanToString(() == ()));
+  Std.printString(Std.booleanToString("hello" == "hello"));
+  Std.printString(Std.booleanToString("hello" == "hel" ++ "lo"));
+  Std.printString(Std.booleanToString(val h: String = "hello"; h == h));
+  Std.printString(Std.booleanToString(Foo1() == Foo1()));
+  Std.printString(Std.booleanToString(Foo1() == Foo2()));
+  Std.printString(Std.booleanToString(val f: Foo = Foo1(); f == f));
+  Std.printString(Std.booleanToString(val f: Foo = Foo1(); val g: Foo = f; f == g))
+end Equality

info/labs/lab01/test/resources/execution/passing/Factorial.grading.amy

+object Factorial
+  def fact(i: Int(32)): Int(32) = {
+    if (i < 2) { 1 }
+    else { i * fact(i-1) }
+  }
+
+  Std.printString("5! = "  ++ Std.intToString(fact(5)));
+  Std.printString("10! = " ++ Std.intToString(fact(10)))
+end Factorial

info/labs/lab01/test/resources/execution/passing/FunCallEnv.grading.amy

+object FunCallEnv
+  def printRec(i: Int(32), j: Int(32)): Unit = {
+    if (i <= 0) { () } else {
+      Std.printInt(i);
+      Std.printInt(j);
+      printRec(i - 1, j / 2)
+    }
+  }
+
+  printRec(3, 8)
+
+end FunCallEnv

info/labs/lab01/test/resources/execution/passing/IntInputToOutput.grading.amy

+object IntInputToOutput
+  val intInput: Int(32) = Std.readInt();
+  Std.printString(Std.intToString(intInput))
+end IntInputToOutput
\ No newline at end of file

info/labs/lab01/test/resources/execution/passing/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(l1, 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 l =>
+        split(l) 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/test/resources/execution/passing/Locals.grading.amy

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

info/labs/lab01/test/resources/execution/passing/Match1.grading.amy

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

info/labs/lab01/test/resources/execution/passing/Match2.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar(i: Int(32), b: Boolean, u: Unit) extends Foo
+
+  Bar(10, true, ()) match { case Bar(10, true, ()) => () }
+end MatchError