WIP: Fix parser for mlton

examples/casestudies/parser.md

@@ -68,11 +68,11 @@ def or[R] { p: => R } { q: => R } =
 def opt[R] { p: => R }: Option[R] / Parser =
   or { Some(p()) } { None() }
 
-def many { p: => Unit }: Unit / Parser =
-  or { some { p() } } { () }
+def many[R] { p: => R }: List[R] / Parser =
+  or { some[R] { p() } } { Nil() }
 
-def some { p: => Unit }: Unit / Parser =
-  { p(); many { p() } }
+def some[R] { p: => R }: List[R] / Parser =
+  { Cons(p(), many { p() }) }
 ```
 
 ## Example: A Simple Expression Language
@@ -171,19 +171,19 @@ The following example implements an example
 ```
 It uses local (mutable) variables to count the number of leafs as semantic action.
 ```
-def parseCalls(): Int / Parser =
+def parseCalls(): Int / Parser = {
   or { number(); 1 } {
-    var count = 1;
     ident();
     punct("(");
-    count = count + parseCalls();
-    many {
+    val count = parseCalls() +
+    sum(many {
         punct(",");
-        count = count + parseCalls()
-    };
+        parseCalls()
+    });
     punct(")");
     count
   }
+}
 ```
 Notice how the user defined combinator `many` feels like a built-in control operator
 `while`.

libraries/jit/immutable/list.effekt

@@ -102,6 +102,11 @@ def any(l: List[Boolean]): Boolean = l match {
   case Nil() => false
   case Cons(v,rest) => if (v) { true } else { any(rest) }
 }
+def sum(l: List[Int]): Int = {
+  var res = 0
+  l.foreach { i => res = res + i }
+  res
+}
 
 // elements that satisfy the predicate go into the left list
 def partition[A](l: List[A]) { pred: A => Boolean }: (List[A], List[A]) = {

libraries/ml/immutable/list.effekt

@@ -84,6 +84,11 @@ def any(l: List[Boolean]): Boolean = l match {
   case Nil() => false
   case Cons(v,rest) => if (v) { true } else { any(rest) }
 }
+def sum(l: List[Int]): Int = {
+  var res = 0
+  l.foreach { i => res = res + i }
+  res
+}
 
 def nonEmpty[A](l: List[A]): Boolean = l match {
   case Nil() => false