Cull extraneous whitespace.

One last flurry with the broom before I leave you slobs to code
in your own filth. Eliminated all the trailing whitespace I
could manage, with special prejudice reserved for the test cases
which depended on the preservation of trailing whitespace.

Was reminded I cannot figure out how to eliminate the trailing
space on the "scala> " prompt in repl transcripts. At least
reduced the number of such empty prompts by trimming transcript
code on the way in.

Routed ConsoleReporter's "printMessage" through a trailing
whitespace stripping method which might help futureproof
against the future of whitespace diseases. Deleted the up-to-40
lines of trailing whitespace found in various library files.

It seems like only yesterday we performed whitespace surgery
on the whole repo. Clearly it doesn't stick very well. I suggest
it would work better to enforce a few requirements on the way in.

1 files changed, 5 insertions, 5 deletions

diff --git a/test/files/pos/sudoku.scala b/test/files/pos/sudoku.scala
index 336dc756a9..9435f504d6 100644
--- a/test/files/pos/sudoku.scala
+++ b/test/files/pos/sudoku.scala
@@ -3,22 +3,22 @@ object SudokuSolver extends App {
   // held in a global variable m. The program begins by reading 9 lines
   // of input to fill the board
   var m: Array[Array[Char]] = Array.tabulate(9)((x: Int) => readLine.toArray)
- 
+
   // For printing m, a method print is defined
   def print = { println(""); m map (carr => println(new String(carr))) }
- 
+
   // The test for validity is performed by looping over i=0..8 and
   // testing the row, column and 3x3 square containing the given
   // coordinate
   def invalid(i: Int, x: Int, y: Int, n: Char): Boolean =
     i<9 && (m(y)(i) == n || m(i)(x) == n ||
       m(y/3*3 + i/3)(x/3*3 + i % 3) == n || invalid(i+1, x, y, n))
- 
+
   // Looping over a half-closed range of consecutive integers [l..u)
   // is factored out into a higher-order function
   def fold(f: (Int, Int) => Int, accu: Int, l: Int, u: Int): Int =
     if(l==u) accu else fold(f, f(accu, l), l+1, u)
- 
+
   // The search function examines each position on the board in turn,
   // trying the numbers 1..9 in each unfilled position
   // The function is itself a higher-order fold, accumulating the value
@@ -34,7 +34,7 @@ object SudokuSolver extends App {
              val newaccu = search(x+1, y, f, accu);
              m(y)(x) = '0';
              newaccu}, accu, 1, 10)}
- 
+
   // The main part of the program uses the search function to accumulate
   // the total number of solutions
   println("\n"+search(0,0,i => {print; i+1},0)+" solution(s)")