adapted code to Scala 2 syntax in files src/exa...

adapted code to Scala 2 syntax in files src/examples/**/*.scala

1 files changed, 51 insertions, 49 deletions

diff --git a/docs/examples/parsers1.scala b/docs/examples/parsers1.scala
index 143f354049..f2a5c48ac3 100644
--- a/docs/examples/parsers1.scala
+++ b/docs/examples/parsers1.scala
@@ -8,9 +8,9 @@ object parsers1 {
 
     abstract class Parser {
 
-      type Result = Option[inputType];
+      type Result = Option[inputType]
 
-      def apply(in: inputType): Result;
+      def apply(in: inputType): Result
 
       /*** p &&& q applies first p, and if that succeeds, then q
        */
@@ -39,79 +39,81 @@ object parsers1 {
       def apply(in: inputType): Result = None
     }
 
-    def opt(p: Parser): Parser = p ||| empty;    // p? = (p | <empty>)
-    def rep(p: Parser): Parser = opt(rep1(p));   // p* = [p+]
-    def rep1(p: Parser): Parser = p &&& rep(p);  // p+ = p p*
+    def opt(p: Parser): Parser = p ||| empty    // p? = (p | <empty>)
+    def rep(p: Parser): Parser = opt(rep1(p))   // p* = [p+]
+    def rep1(p: Parser): Parser = p &&& rep(p)  // p+ = p p*
   }
 
-  abstract class ListParsers extends Parsers {
-    def chr(p: char => boolean): Parser;
-    def chr(c: char): Parser = chr(d: char => d == c);
+  mixin class ListParsers extends Parsers {
+    def chr(p: char => boolean): Parser
+    def chr(c: char): Parser = chr(d: char => d == c)
 
-    def letter    : Parser = chr(Character.isLetter);
-    def digit     : Parser = chr(Character.isDigit);
+    def letter    : Parser = chr(c: char => Character.isLetter(c))
+    def digit     : Parser = chr(c: char => Character.isDigit(c))
 
-    def ident     : Parser = letter &&& rep(letter ||| digit);
-    def number    : Parser = digit &&& rep(digit);
-    def list      : Parser = chr('(') &&& listElems &&& chr(')');
-    def listElems : Parser = expr &&& (chr(',') &&& listElems ||| empty);
-    def expr      : Parser = ident ||| number ||| list;
+    def ident     : Parser = letter &&& rep(letter ||| digit)
+    def number    : Parser = digit &&& rep(digit)
+    def list      : Parser = chr('(') &&& listElems &&& chr(')')
+    def listElems : Parser = expr &&& (chr(',') &&& listElems ||| empty)
+    def expr      : Parser = ident ||| number ||| list
   }
 
-  abstract class ExprParsers extends Parsers {
-    def chr(p: char => boolean): Parser;
-    def chr(c: char): Parser = chr(d: char => d == c);
+  mixin class ExprParsers extends Parsers {
+    def chr(p: char => boolean): Parser
+    def chr(c: char): Parser = chr(d: char => d == c)
 
-    def digit     : Parser = chr(Character.isDigit);
-    def number    : Parser = digit &&& rep(digit);
-    def summand   : Parser = number ||| chr('(') &&& expr &&& chr(')');
+    def digit     : Parser = chr(c: char => Character.isDigit(c))
+    def number    : Parser = digit &&& rep(digit)
+    def summand   : Parser = number ||| chr('(') &&& expr &&& chr(')')
     def expr      : Parser = summand &&& rep(chr('+') &&& summand)
   }
 
   class ParseString(s: String) extends Parsers {
-    type inputType = int;
-    val input = 0;
+    type inputType = Int
+    val input = 0
     def chr(p: char => boolean) = new Parser {
       def apply(in: int): Parser#Result =
-        if (in < s.length() && p(s charAt in)) Some(in + 1);
-        else None;
+        if (in < s.length() && p(s charAt in)) Some(in + 1)
+        else None
     }
   }
 
   object TestList {
-
-    def main(args: Array[String]): unit =
-      if (args.length == 1) {
-        val ps = new ListParsers with ParseString(args(0));
-        ps.expr(ps.input) match {
-          case Some(n) =>
-            Console.println("parsed: " + args(0).substring(0, n));
-          case None =>
-            Console.println("nothing parsed");
+    def main(args: Array[String]): Unit =
+      Console.println(
+        if (args.length == 1) {
+          val ps = new ParseString(args(0)) with ListParsers
+          ps.expr(ps.input) match {
+            case Some(n) =>
+              "parsed: " + args(0).substring(0, n)
+            case None =>
+              "nothing parsed"
+          }
         }
-      }
-      else
-        Console.println("usage: java examples.TestList <expr-string>");
+        else
+          "usage: java examples.TestList <expr-string>"
+      )
   }
 
   object TestExpr {
-
     def main(args: Array[String]): unit =
-      if (args.length == 1) {
-        val ps = new ExprParsers with ParseString(args(0));
-        ps.expr(ps.input) match {
-          case Some(n) =>
-            Console.println("parsed: " + args(0).substring(0, n));
-          case None =>
-            Console.println("nothing parsed");
+      Console.println(
+        if (args.length == 1) {
+          val ps = new ParseString(args(0)) with ExprParsers
+          ps.expr(ps.input) match {
+            case Some(n) =>
+              "parsed: " + args(0).substring(0, n)
+            case None =>
+              "nothing parsed"
+          }
         }
-      }
-      else
-        Console.println("usage: java examples.TestExpr <expr-string>");
+        else
+          "usage: java examples.TestExpr <expr-string>"
+      )
   }
 
   def main(args: Array[String]): Unit = {
-    TestList.main(Array("(a,b,(1,2))"));
+    TestList.main(Array("(a,b,(1,2))"))
     TestExpr.main(Array("2+3+(4+1)"))
   }