Whitespace fixes in scala/tools/scalap

Author: soc

src/scalap/scala/tools/scalap/rules/Memoisable.scala

@@ -15,19 +15,19 @@ package scala.tools.scalap.rules
 import scala.collection.mutable
 
 trait MemoisableRules extends Rules {
-  def memo[In <: Memoisable, Out, A, X](key : AnyRef)(toRule : => In => Result[Out, A, X]) = {
+  def memo[In <: Memoisable, Out, A, X](key: AnyRef)(toRule: => In => Result[Out, A, X]) = {
     lazy val rule = toRule
     from[In] { in => in.memo(key, rule(in)) }
   }
 
-  override def ruleWithName[In, Out, A, X](name : String, f : In => Result[Out, A, X]) = super.ruleWithName(name, (in : In) => in match {
-      case s : Memoisable => s.memo(name, f(in))
+  override def ruleWithName[In, Out, A, X](name: String, f: In => Result[Out, A, X]) = super.ruleWithName(name, (in: In) => in match {
+      case s: Memoisable => s.memo(name, f(in))
       case _ => f(in)
     })
 }
 
 trait Memoisable {
-  def memo[A](key : AnyRef, a : => A) : A
+  def memo[A](key: AnyRef, a: => A): A
 }
 
 
@@ -38,18 +38,18 @@ object DefaultMemoisable {
 trait DefaultMemoisable extends Memoisable {
   protected val map = new mutable.HashMap[AnyRef, Any]
 
-  def memo[A](key : AnyRef, a : => A) = {
+  def memo[A](key: AnyRef, a: => A) = {
     map.getOrElseUpdate(key, compute(key, a)).asInstanceOf[A]
   }
 
-  protected def compute[A](key : AnyRef, a : => A): Any = a match {
-    case success : Success[_, _] => onSuccess(key, success); success
+  protected def compute[A](key: AnyRef, a: => A): Any = a match {
+    case success: Success[_, _] => onSuccess(key, success); success
     case other =>
       if(DefaultMemoisable.debug) println(key + " -> " + other)
       other
   }
 
-  protected def onSuccess[S, T](key : AnyRef,  result : Success[S, T])  {
+  protected def onSuccess[S, T](key: AnyRef,  result: Success[S, T])  {
     val Success(out, t) = result
     if(DefaultMemoisable.debug) println(key + " -> " + t + " (" + out + ")")
   }

src/scalap/scala/tools/scalap/rules/Result.scala

@@ -16,35 +16,35 @@ package scala.tools.scalap.rules;
  *
  * @see the Scala parser combinator
  */
-case class ~[+A, +B](_1 : A, _2 : B) {
+case class ~[+A, +B](_1: A, _2: B) {
   override def toString = "(" + _1 + " ~ " + _2 + ")"
 }
 
 
 sealed abstract class Result[+Out, +A, +X] {
-  def out : Out
-  def value : A
-  def error : X
+  def out: Out
+  def value: A
+  def error: X
 
-  implicit def toOption : Option[A]
+  implicit def toOption: Option[A]
 
-  def map[B](f : A => B) : Result[Out, B, X]
-  def mapOut[Out2](f : Out => Out2) : Result[Out2, A, X]
-  def map[Out2, B](f : (Out, A) => (Out2, B)) : Result[Out2, B, X]
-  def flatMap[Out2, B](f : (Out, A) => Result[Out2, B, Nothing]) : Result[Out2, B, X]
-  def orElse[Out2 >: Out, B >: A](other : => Result[Out2, B, Nothing]) : Result[Out2, B, X]
+  def map[B](f: A => B): Result[Out, B, X]
+  def mapOut[Out2](f: Out => Out2): Result[Out2, A, X]
+  def map[Out2, B](f: (Out, A) => (Out2, B)): Result[Out2, B, X]
+  def flatMap[Out2, B](f: (Out, A) => Result[Out2, B, Nothing]): Result[Out2, B, X]
+  def orElse[Out2 >: Out, B >: A](other: => Result[Out2, B, Nothing]): Result[Out2, B, X]
 }
 
-case class Success[+Out, +A](out : Out, value : A) extends Result[Out, A, Nothing] {
+case class Success[+Out, +A](out: Out, value: A) extends Result[Out, A, Nothing] {
   def error = throw new ScalaSigParserError("No error")
 
   def toOption = Some(value)
 
-  def map[B](f : A => B) : Result[Out, B, Nothing] = Success(out, f(value))
-  def mapOut[Out2](f : Out => Out2) : Result[Out2, A, Nothing] = Success(f(out), value)
-  def map[Out2, B](f : (Out, A) => (Out2, B)) : Success[Out2, B] = f(out, value) match { case (out2, b) => Success(out2, b) }
-  def flatMap[Out2, B](f : (Out, A) => Result[Out2, B, Nothing]) : Result[Out2, B, Nothing]= f(out, value)
-  def orElse[Out2 >: Out, B >: A](other : => Result[Out2, B, Nothing]) : Result[Out2, B, Nothing] = this
+  def map[B](f: A => B): Result[Out, B, Nothing] = Success(out, f(value))
+  def mapOut[Out2](f: Out => Out2): Result[Out2, A, Nothing] = Success(f(out), value)
+  def map[Out2, B](f: (Out, A) => (Out2, B)): Success[Out2, B] = f(out, value) match { case (out2, b) => Success(out2, b) }
+  def flatMap[Out2, B](f: (Out, A) => Result[Out2, B, Nothing]): Result[Out2, B, Nothing]= f(out, value)
+  def orElse[Out2 >: Out, B >: A](other: => Result[Out2, B, Nothing]): Result[Out2, B, Nothing] = this
 }
 
 sealed abstract class NoSuccess[+X] extends Result[Nothing, Nothing, X] {
@@ -53,11 +53,11 @@ sealed abstract class NoSuccess[+X] extends Result[Nothing, Nothing, X] {
 
   def toOption = None
 
-  def map[B](f : Nothing => B) = this
-  def mapOut[Out2](f : Nothing => Out2) = this
-  def map[Out2, B](f : (Nothing, Nothing) => (Out2, B)) = this
-  def flatMap[Out2, B](f : (Nothing, Nothing) => Result[Out2, B, Nothing]) = this
-  def orElse[Out2, B](other : => Result[Out2, B, Nothing]) = other
+  def map[B](f: Nothing => B) = this
+  def mapOut[Out2](f: Nothing => Out2) = this
+  def map[Out2, B](f: (Nothing, Nothing) => (Out2, B)) = this
+  def flatMap[Out2, B](f: (Nothing, Nothing) => Result[Out2, B, Nothing]) = this
+  def orElse[Out2, B](other: => Result[Out2, B, Nothing]) = other
 }
 
 case object Failure extends NoSuccess[Nothing] {
@@ -66,5 +66,4 @@ case object Failure extends NoSuccess[Nothing] {
 
 case class ScalaSigParserError(msg: String) extends RuntimeException(msg)
 
-case class Error[+X](error : X) extends NoSuccess[X] {
-}
+case class Error[+X](error: X) extends NoSuccess[X]

src/scalap/scala/tools/scalap/rules/Rule.scala

@@ -24,138 +24,138 @@ package scala.tools.scalap.rules
   * Inspired by the Scala parser combinator.
   */
 trait Rule[-In, +Out, +A, +X] extends (In => Result[Out, A, X]) {
-  val factory : Rules
+  val factory: Rules
   import factory._
 
-  def as(name : String) = ruleWithName(name, this)
+  def as(name: String) = ruleWithName(name, this)
 
-  def flatMap[Out2, B, X2 >: X](fa2ruleb : A => Out => Result[Out2, B, X2]) = mapResult {
+  def flatMap[Out2, B, X2 >: X](fa2ruleb: A => Out => Result[Out2, B, X2]) = mapResult {
       case Success(out, a) => fa2ruleb(a)(out)
       case Failure => Failure
       case err @ Error(_) => err
   }
 
-  def map[B](fa2b : A => B) = flatMap { a => out => Success(out, fa2b(a)) }
+  def map[B](fa2b: A => B) = flatMap { a => out => Success(out, fa2b(a)) }
 
-  def filter(f : A => Boolean) = flatMap { a => out => if(f(a)) Success(out, a) else Failure }
+  def filter(f: A => Boolean) = flatMap { a => out => if(f(a)) Success(out, a) else Failure }
 
-  def mapResult[Out2, B, Y](f : Result[Out, A, X] => Result[Out2, B, Y]) = rule {
-    in : In => f(apply(in))
+  def mapResult[Out2, B, Y](f: Result[Out, A, X] => Result[Out2, B, Y]) = rule {
+    in: In => f(apply(in))
   }
 
-  def orElse[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other : => Rule[In2, Out2, A2, X2]) : Rule[In2, Out2, A2, X2] = new Choice[In2, Out2, A2, X2] {
+  def orElse[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other: => Rule[In2, Out2, A2, X2]): Rule[In2, Out2, A2, X2] = new Choice[In2, Out2, A2, X2] {
     val factory = Rule.this.factory
     lazy val choices = Rule.this :: other :: Nil
   }
 
   def orError[In2 <: In] = this orElse error[Any]
 
-  def |[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other : => Rule[In2, Out2, A2, X2]) = orElse(other)
+  def |[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other: => Rule[In2, Out2, A2, X2]) = orElse(other)
 
-  def ^^[B](fa2b : A => B) = map(fa2b)
+  def ^^[B](fa2b: A => B) = map(fa2b)
 
-  def ^^?[B](pf : PartialFunction[A, B]) = filter (pf.isDefinedAt(_)) ^^ pf
+  def ^^?[B](pf: PartialFunction[A, B]) = filter (pf.isDefinedAt(_)) ^^ pf
 
-  def ??(pf : PartialFunction[A, Any]) = filter (pf.isDefinedAt(_))
+  def ??(pf: PartialFunction[A, Any]) = filter (pf.isDefinedAt(_))
 
-  def -^[B](b : B) = map { any => b }
+  def -^[B](b: B) = map { any => b }
 
   /** Maps an Error */
-  def !^[Y](fx2y : X => Y) = mapResult {
+  def !^[Y](fx2y: X => Y) = mapResult {
     case s @ Success(_, _) => s
     case Failure => Failure
     case Error(x) => Error(fx2y(x))
   }
 
-  def >>[Out2, B, X2 >: X](fa2ruleb : A => Out => Result[Out2, B, X2]) = flatMap(fa2ruleb)
+  def >>[Out2, B, X2 >: X](fa2ruleb: A => Out => Result[Out2, B, X2]) = flatMap(fa2ruleb)
 
-  def >->[Out2, B, X2 >: X](fa2resultb : A => Result[Out2, B, X2]) = flatMap { a => any => fa2resultb(a) }
+  def >->[Out2, B, X2 >: X](fa2resultb: A => Result[Out2, B, X2]) = flatMap { a => any => fa2resultb(a) }
 
-  def >>?[Out2, B, X2 >: X](pf : PartialFunction[A, Rule[Out, Out2, B, X2]]) = filter(pf isDefinedAt _) flatMap pf
+  def >>?[Out2, B, X2 >: X](pf: PartialFunction[A, Rule[Out, Out2, B, X2]]) = filter(pf isDefinedAt _) flatMap pf
 
-  def >>&[B, X2 >: X](fa2ruleb : A => Out => Result[Any, B, X2]) = flatMap { a => out => fa2ruleb(a)(out) mapOut { any => out } }
+  def >>&[B, X2 >: X](fa2ruleb: A => Out => Result[Any, B, X2]) = flatMap { a => out => fa2ruleb(a)(out) mapOut { any => out } }
 
-  def ~[Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next) yield new ~(a, b)
+  def ~[Out2, B, X2 >: X](next: => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next) yield new ~(a, b)
 
-  def ~-[Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next) yield a
+  def ~-[Out2, B, X2 >: X](next: => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next) yield a
 
-  def -~[Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next) yield b
+  def -~[Out2, B, X2 >: X](next: => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next) yield b
 
-  def ~++[Out2, B >: A, X2 >: X](next : => Rule[Out, Out2, Seq[B], X2]) = for (a <- this; b <- next) yield a :: b.toList
+  def ~++[Out2, B >: A, X2 >: X](next: => Rule[Out, Out2, Seq[B], X2]) = for (a <- this; b <- next) yield a :: b.toList
 
   /** Apply the result of this rule to the function returned by the next rule */
-  def ~>[Out2, B, X2 >: X](next : => Rule[Out, Out2, A => B, X2]) = for (a <- this; fa2b <- next) yield fa2b(a)
+  def ~>[Out2, B, X2 >: X](next: => Rule[Out, Out2, A => B, X2]) = for (a <- this; fa2b <- next) yield fa2b(a)
 
   /** Apply the result of this rule to the function returned by the previous rule */
-  def <~:[InPrev, B, X2 >: X](prev : => Rule[InPrev, In, A => B, X2]) = for (fa2b <- prev; a <- this) yield fa2b(a)
+  def <~:[InPrev, B, X2 >: X](prev: => Rule[InPrev, In, A => B, X2]) = for (fa2b <- prev; a <- this) yield fa2b(a)
 
-  def ~![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield new ~(a, b)
+  def ~![Out2, B, X2 >: X](next: => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield new ~(a, b)
 
-  def ~-![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield a
+  def ~-![Out2, B, X2 >: X](next: => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield a
 
-  def -~![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield b
+  def -~![Out2, B, X2 >: X](next: => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield b
 
-  def -[In2 <: In](exclude : => Rule[In2, Any, Any, Any]) = !exclude -~ this
+  def -[In2 <: In](exclude: => Rule[In2, Any, Any, Any]) = !exclude -~ this
 
   /** ^~^(f) is equivalent to ^^ { case b1 ~ b2 => f(b1, b2) }
    */
-  def ^~^[B1, B2, B >: A <% B1 ~ B2, C](f : (B1, B2) => C) = map { a =>
-    (a : B1 ~ B2) match { case b1 ~ b2 => f(b1, b2) }
+  def ^~^[B1, B2, B >: A <% B1 ~ B2, C](f: (B1, B2) => C) = map { a =>
+    (a: B1 ~ B2) match { case b1 ~ b2 => f(b1, b2) }
   }
 
   /** ^~~^(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 => f(b1, b2, b3) }
    */
-  def ^~~^[B1, B2, B3, B >: A <% B1 ~ B2 ~ B3, C](f : (B1, B2, B3) => C) = map { a =>
-    (a : B1 ~ B2 ~ B3) match { case b1 ~ b2 ~ b3 => f(b1, b2, b3) }
+  def ^~~^[B1, B2, B3, B >: A <% B1 ~ B2 ~ B3, C](f: (B1, B2, B3) => C) = map { a =>
+    (a: B1 ~ B2 ~ B3) match { case b1 ~ b2 ~ b3 => f(b1, b2, b3) }
   }
 
   /** ^~~~^(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 => f(b1, b2, b3, b4) }
    */
-  def ^~~~^[B1, B2, B3, B4, B >: A <% B1 ~ B2 ~ B3 ~ B4, C](f : (B1, B2, B3, B4) => C) = map { a =>
-    (a : B1 ~ B2 ~ B3 ~ B4) match { case b1 ~ b2 ~ b3 ~ b4 => f(b1, b2, b3, b4) }
+  def ^~~~^[B1, B2, B3, B4, B >: A <% B1 ~ B2 ~ B3 ~ B4, C](f: (B1, B2, B3, B4) => C) = map { a =>
+    (a: B1 ~ B2 ~ B3 ~ B4) match { case b1 ~ b2 ~ b3 ~ b4 => f(b1, b2, b3, b4) }
   }
 
   /** ^~~~~^(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 ~ b5 => f(b1, b2, b3, b4, b5) }
    */
-  def ^~~~~^[B1, B2, B3, B4, B5, B >: A <% B1 ~ B2 ~ B3 ~ B4 ~ B5, C](f : (B1, B2, B3, B4, B5) => C) = map { a =>
-    (a : B1 ~ B2 ~ B3 ~ B4 ~ B5) match { case b1 ~ b2 ~ b3 ~ b4 ~ b5 => f(b1, b2, b3, b4, b5) }
+  def ^~~~~^[B1, B2, B3, B4, B5, B >: A <% B1 ~ B2 ~ B3 ~ B4 ~ B5, C](f: (B1, B2, B3, B4, B5) => C) = map { a =>
+    (a: B1 ~ B2 ~ B3 ~ B4 ~ B5) match { case b1 ~ b2 ~ b3 ~ b4 ~ b5 => f(b1, b2, b3, b4, b5) }
   }
 
   /** ^~~~~~^(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 => f(b1, b2, b3, b4, b5, b6) }
    */
-  def ^~~~~~^[B1, B2, B3, B4, B5, B6, B >: A <% B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6, C](f : (B1, B2, B3, B4, B5, B6) => C) = map { a =>
-    (a : B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6) match { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 => f(b1, b2, b3, b4, b5, b6) }
+  def ^~~~~~^[B1, B2, B3, B4, B5, B6, B >: A <% B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6, C](f: (B1, B2, B3, B4, B5, B6) => C) = map { a =>
+    (a: B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6) match { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 => f(b1, b2, b3, b4, b5, b6) }
   }
 
   /** ^~~~~~~^(f) is equivalent to ^^ { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 => f(b1, b2, b3, b4, b5, b6) }
    */
-  def ^~~~~~~^[B1, B2, B3, B4, B5, B6, B7, B >: A <% B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6 ~ B7, C](f : (B1, B2, B3, B4, B5, B6, B7) => C) = map { a =>
-    (a : B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6 ~ B7) match { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 ~b7 => f(b1, b2, b3, b4, b5, b6, b7) }
+  def ^~~~~~~^[B1, B2, B3, B4, B5, B6, B7, B >: A <% B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6 ~ B7, C](f: (B1, B2, B3, B4, B5, B6, B7) => C) = map { a =>
+    (a: B1 ~ B2 ~ B3 ~ B4 ~ B5 ~ B6 ~ B7) match { case b1 ~ b2 ~ b3 ~ b4 ~ b5 ~ b6 ~b7 => f(b1, b2, b3, b4, b5, b6, b7) }
   }
 
   /** >~>(f) is equivalent to >> { case b1 ~ b2 => f(b1, b2) }
    */
-  def >~>[Out2, B1, B2, B >: A <% B1 ~ B2, C, X2 >: X](f : (B1, B2) => Out => Result[Out2, C, X2]) = flatMap { a =>
-    (a : B1 ~ B2) match { case b1 ~ b2 => f(b1, b2) }
+  def >~>[Out2, B1, B2, B >: A <% B1 ~ B2, C, X2 >: X](f: (B1, B2) => Out => Result[Out2, C, X2]) = flatMap { a =>
+    (a: B1 ~ B2) match { case b1 ~ b2 => f(b1, b2) }
   }
 
   /** ^-^(f) is equivalent to ^^ { b2 => b1 => f(b1, b2) }
    */
-  def ^-^ [B1, B2 >: A, C](f : (B1, B2) => C) = map { b2 : B2 => b1 : B1 => f(b1, b2) }
+  def ^-^ [B1, B2 >: A, C](f: (B1, B2) => C) = map { b2: B2 => b1: B1 => f(b1, b2) }
 
  /** ^~>~^(f) is equivalent to ^^ { case b2 ~ b3 => b1 => f(b1, b2, b3) }
   */
- def ^~>~^ [B1, B2, B3, B >: A <% B2 ~ B3, C](f : (B1, B2, B3) => C) = map { a =>
-   (a : B2 ~ B3) match { case b2 ~ b3 => b1 : B1 => f(b1, b2, b3) }
+ def ^~>~^ [B1, B2, B3, B >: A <% B2 ~ B3, C](f: (B1, B2, B3) => C) = map { a =>
+   (a: B2 ~ B3) match { case b2 ~ b3 => b1: B1 => f(b1, b2, b3) }
  }
 }
 
 
 trait Choice[-In, +Out, +A, +X] extends Rule[In, Out, A, X] {
-  def choices : List[Rule[In, Out, A, X]]
+  def choices: List[Rule[In, Out, A, X]]
 
-  def apply(in : In) = {
-    def oneOf(list : List[Rule[In, Out, A, X]]) : Result[Out, A, X] = list match {
+  def apply(in: In) = {
+    def oneOf(list: List[Rule[In, Out, A, X]]): Result[Out, A, X] = list match {
       case Nil => Failure
       case first :: rest => first(in) match {
         case Failure => oneOf(rest)
@@ -165,7 +165,7 @@ trait Choice[-In, +Out, +A, +X] extends Rule[In, Out, A, X] {
     oneOf(choices)
   }
 
-  override def orElse[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other : => Rule[In2, Out2, A2, X2]) : Rule[In2, Out2, A2, X2] = new Choice[In2, Out2, A2, X2] {
+  override def orElse[In2 <: In, Out2 >: Out, A2 >: A, X2 >: X](other: => Rule[In2, Out2, A2, X2]): Rule[In2, Out2, A2, X2] = new Choice[In2, Out2, A2, X2] {
     val factory = Choice.this.factory
     lazy val choices = Choice.this.choices ::: other :: Nil
   }