Merge pull request #319 from twitter/formattingFixup

Little commit fixing up some spacing per our norms:

algebird-core/src/main/scala/com/twitter/algebird/Monoid.scala

@@ -31,7 +31,7 @@ import scala.collection.{Map => ScMap}
  */
 
 @implicitNotFound(msg = "Cannot find Monoid type class for ${T}")
-trait Monoid[@specialized(Int,Long,Float,Double) T] extends Semigroup[T] {
+trait Monoid[@specialized(Int, Long, Float, Double) T] extends Semigroup[T] {
   def zero : T //additive identity
   def isNonZero(v: T): Boolean = (v != zero)
   def assertNotZero(v : T) {
@@ -59,7 +59,7 @@ abstract class AbstractMonoid[T] extends Monoid[T]
  * Some(5) + Some(3) == Some(8)
  * Some(5) + None == Some(5)
  */
-class OptionMonoid[T](implicit semi : Semigroup[T]) extends Monoid[Option[T]] {
+class OptionMonoid[T](implicit semi: Semigroup[T]) extends Monoid[Option[T]] {
   def zero = None
   def plus(left : Option[T], right : Option[T]) : Option[T] = {
     if(left.isEmpty) {
@@ -77,7 +77,7 @@ class OptionMonoid[T](implicit semi : Semigroup[T]) extends Monoid[Option[T]] {
     else Some(Semigroup.sumOption(items.filter(_.isDefined).map { _.get }))
 }
 
-class EitherMonoid[L,R](implicit semigroupl : Semigroup[L], monoidr : Monoid[R]) extends EitherSemigroup[L, R]()(semigroupl, monoidr) with Monoid[Either[L,R]] {
+class EitherMonoid[L, R](implicit semigroupl: Semigroup[L], monoidr: Monoid[R]) extends EitherSemigroup[L, R]()(semigroupl, monoidr) with Monoid[Either[L, R]] {
   override lazy val zero = Right(monoidr.zero)
 }
 
@@ -124,12 +124,12 @@ class SetMonoid[T] extends Monoid[Set[T]] {
 /** Function1 monoid.
  * plus means function composition, zero is the identity function
  */
-class Function1Monoid[T] extends Monoid[Function1[T,T]] {
+class Function1Monoid[T] extends Monoid[Function1[T, T]] {
   override def zero = identity[T]
 
   // (f1 + f2)(x) = f2(f1(x)) so that:
   // listOfFn.foldLeft(x) { (v, fn) => fn(v) } = (Monoid.sum(listOfFn))(x)
-  override def plus(f1 : Function1[T,T], f2 : Function1[T,T]) = {
+  override def plus(f1 : Function1[T, T], f2 : Function1[T, T]) = {
     (t : T) => f2(f1(t))
   }
 }
@@ -166,27 +166,27 @@ object AndValMonoid extends Monoid[AndVal] {
 
 object Monoid extends GeneratedMonoidImplicits with ProductMonoids {
   // This pattern is really useful for typeclasses
-  def zero[T](implicit mon : Monoid[T]) = mon.zero
+  def zero[T](implicit mon: Monoid[T]) = mon.zero
   // strictly speaking, same as Semigroup, but most interesting examples
   // are monoids, and code already depends on this:
-  def plus[T](l: T, r: T)(implicit monoid: Monoid[T]): T = monoid.plus(l,r)
+  def plus[T](l: T, r: T)(implicit monoid: Monoid[T]): T = monoid.plus(l, r)
   def assertNotZero[T](v: T)(implicit monoid: Monoid[T]) = monoid.assertNotZero(v)
   def isNonZero[T](v: T)(implicit monoid: Monoid[T]) = monoid.isNonZero(v)
   def nonZeroOption[T](v: T)(implicit monoid: Monoid[T]) = monoid.nonZeroOption(v)
   // Left sum: (((a + b) + c) + d)
   def sum[T](iter : TraversableOnce[T])(implicit monoid: Monoid[T]): T =
     monoid.sum(iter)
 
-  def from[T](z: => T)(associativeFn: (T,T) => T): Monoid[T] = new Monoid[T] {
+  def from[T](z: => T)(associativeFn: (T, T) => T): Monoid[T] = new Monoid[T] {
     lazy val zero = z
-    def plus(l:T, r:T) = associativeFn(l,r)
+    def plus(l:T, r:T) = associativeFn(l, r)
   }
 
   /** Return an Equiv[T] that uses isNonZero to return equality for all zeros
    * useful for Maps/Vectors that have many equivalent in memory representations of zero
    */
   def zeroEquiv[T:Equiv:Monoid]: Equiv[T] = Equiv.fromFunction { (a: T, b: T) =>
-    (!isNonZero(a) && !isNonZero(b)) || Equiv[T].equiv(a,b)
+    (!isNonZero(a) && !isNonZero(b)) || Equiv[T].equiv(a, b)
   }
 
   /** Same as v + v + v .. + v (i times in total)
@@ -202,31 +202,31 @@ object Monoid extends GeneratedMonoidImplicits with ProductMonoids {
     }
   }
 
-  implicit val nullMonoid : Monoid[Null] = NullGroup
-  implicit val unitMonoid : Monoid[Unit] = UnitGroup
-  implicit val boolMonoid : Monoid[Boolean] = BooleanField
-  implicit val jboolMonoid : Monoid[JBool] = JBoolField
-  implicit val intMonoid : Monoid[Int] = IntRing
-  implicit val jintMonoid : Monoid[JInt] = JIntRing
-  implicit val shortMonoid : Monoid[Short] = ShortRing
-  implicit val jshortMonoid : Monoid[JShort] = JShortRing
-  implicit val bigIntMonoid : Monoid[BigInt] = BigIntRing
-  implicit val longMonoid : Monoid[Long] = LongRing
-  implicit val jlongMonoid : Monoid[JLong] = JLongRing
-  implicit val floatMonoid : Monoid[Float] = FloatField
-  implicit val jfloatMonoid : Monoid[JFloat] = JFloatField
-  implicit val doubleMonoid : Monoid[Double] = DoubleField
-  implicit val jdoubleMonoid : Monoid[JDouble] = JDoubleField
-  implicit val stringMonoid : Monoid[String] = StringMonoid
-  implicit def optionMonoid[T : Semigroup] : Monoid[Option[T]] = new OptionMonoid[T]
-  implicit def listMonoid[T] : Monoid[List[T]] = new ListMonoid[T]
-  implicit def seqMonoid[T] : Monoid[Seq[T]] = new SeqMonoid[T]
-  implicit def indexedSeqMonoid[T:Monoid] : Monoid[IndexedSeq[T]] = new IndexedSeqMonoid[T]
-  implicit def jlistMonoid[T] : Monoid[JList[T]] = new JListMonoid[T]
-  implicit def setMonoid[T] : Monoid[Set[T]] = new SetMonoid[T]
-  implicit def mapMonoid[K,V: Semigroup] : Monoid[Map[K,V]] = new MapMonoid[K,V]
-  implicit def scMapMonoid[K,V: Semigroup] : Monoid[ScMap[K,V]] = new ScMapMonoid[K,V]
-  implicit def jmapMonoid[K,V : Semigroup] : Monoid[JMap[K,V]] = new JMapMonoid[K,V]
-  implicit def eitherMonoid[L : Semigroup, R : Monoid] : Monoid[Either[L,R]] = new EitherMonoid[L, R]
-  implicit def function1Monoid[T] : Monoid[Function1[T,T]] = new Function1Monoid[T]
+  implicit val nullMonoid: Monoid[Null] = NullGroup
+  implicit val unitMonoid: Monoid[Unit] = UnitGroup
+  implicit val boolMonoid: Monoid[Boolean] = BooleanField
+  implicit val jboolMonoid: Monoid[JBool] = JBoolField
+  implicit val intMonoid: Monoid[Int] = IntRing
+  implicit val jintMonoid: Monoid[JInt] = JIntRing
+  implicit val shortMonoid: Monoid[Short] = ShortRing
+  implicit val jshortMonoid: Monoid[JShort] = JShortRing
+  implicit val bigIntMonoid: Monoid[BigInt] = BigIntRing
+  implicit val longMonoid: Monoid[Long] = LongRing
+  implicit val jlongMonoid: Monoid[JLong] = JLongRing
+  implicit val floatMonoid: Monoid[Float] = FloatField
+  implicit val jfloatMonoid: Monoid[JFloat] = JFloatField
+  implicit val doubleMonoid: Monoid[Double] = DoubleField
+  implicit val jdoubleMonoid: Monoid[JDouble] = JDoubleField
+  implicit val stringMonoid: Monoid[String] = StringMonoid
+  implicit def optionMonoid[T: Semigroup]: Monoid[Option[T]] = new OptionMonoid[T]
+  implicit def listMonoid[T]: Monoid[List[T]] = new ListMonoid[T]
+  implicit def seqMonoid[T]: Monoid[Seq[T]] = new SeqMonoid[T]
+  implicit def indexedSeqMonoid[T:Monoid]: Monoid[IndexedSeq[T]] = new IndexedSeqMonoid[T]
+  implicit def jlistMonoid[T]: Monoid[JList[T]] = new JListMonoid[T]
+  implicit def setMonoid[T]: Monoid[Set[T]] = new SetMonoid[T]
+  implicit def mapMonoid[K, V: Semigroup]: Monoid[Map[K, V]] = new MapMonoid[K, V]
+  implicit def scMapMonoid[K, V: Semigroup]: Monoid[ScMap[K, V]] = new ScMapMonoid[K, V]
+  implicit def jmapMonoid[K, V: Semigroup]: Monoid[JMap[K, V]] = new JMapMonoid[K, V]
+  implicit def eitherMonoid[L: Semigroup, R: Monoid]: Monoid[Either[L, R]] = new EitherMonoid[L, R]
+  implicit def function1Monoid[T]: Monoid[Function1[T, T]] = new Function1Monoid[T]
 }

algebird-core/src/main/scala/com/twitter/algebird/Semigroup.scala

@@ -27,8 +27,8 @@ import scala.annotation.{implicitNotFound, tailrec}
  *   This is a class with a plus method that is associative: a+(b+c) = (a+b)+c
  */
 @implicitNotFound(msg = "Cannot find Semigroup type class for ${T}")
-trait Semigroup[@specialized(Int,Long,Float,Double) T] extends java.io.Serializable {
-  def plus(l : T, r : T) : T
+trait Semigroup[@specialized(Int, Long, Float, Double) T] extends java.io.Serializable {
+  def plus(l: T, r: T): T
   /**
    * override this if there is a faster way to do this sum than reduceLeftOption on plus
    */
@@ -41,13 +41,13 @@ abstract class AbstractSemigroup[T] extends Semigroup[T]
 
 /** Either semigroup is useful for error handling.
  * if everything is correct, use Right (it's right, get it?), if something goes
- * wrong, use Left.  plus does the normal thing for plus(Right,Right), or plus(Left,Left),
+ * wrong, use Left.  plus does the normal thing for plus(Right, Right), or plus(Left, Left),
  * but if exactly one is Left, we return that value (to keep the error condition).
  * Typically, the left value will be a string representing the errors.
  */
-class EitherSemigroup[L,R](implicit semigroupl : Semigroup[L], semigroupr : Semigroup[R]) extends Semigroup[Either[L,R]] {
+class EitherSemigroup[L, R](implicit semigroupl: Semigroup[L], semigroupr: Semigroup[R]) extends Semigroup[Either[L, R]] {
 
-  override def plus(l : Either[L,R], r : Either[L,R]) = {
+  override def plus(l: Either[L, R], r: Either[L, R]) = {
     if(l.isLeft) {
       // l is Left, r may or may not be:
       if(r.isRight) {
@@ -72,12 +72,12 @@ class EitherSemigroup[L,R](implicit semigroupl : Semigroup[L], semigroupr : Semi
 
 object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups {
   // This pattern is really useful for typeclasses
-  def plus[T](l : T, r : T)(implicit semi : Semigroup[T]) = semi.plus(l,r)
+  def plus[T](l: T, r: T)(implicit semi: Semigroup[T]) = semi.plus(l, r)
   // Left sum: (((a + b) + c) + d)
-  def sumOption[T](iter: TraversableOnce[T])(implicit sg: Semigroup[T]) : Option[T] =
+  def sumOption[T](iter: TraversableOnce[T])(implicit sg: Semigroup[T]): Option[T] =
     sg.sumOption(iter)
 
-  def from[T](associativeFn: (T,T) => T): Semigroup[T] = new Semigroup[T] { def plus(l:T, r:T) = associativeFn(l,r) }
+  def from[T](associativeFn: (T, T) => T): Semigroup[T] = new Semigroup[T] { def plus(l:T, r:T) = associativeFn(l, r) }
 
   /** Same as v + v + v .. + v (i times in total)
    * requires i > 0, wish we had PositiveBigInt as a class
@@ -88,7 +88,7 @@ object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups {
   }
 
   @tailrec
-  private def intTimesRec[T](i: BigInt, v: T, pow: Int, vaccMemo: (T,Vector[T]))(implicit sg: Semigroup[T]): T = {
+  private def intTimesRec[T](i: BigInt, v: T, pow: Int, vaccMemo: (T, Vector[T]))(implicit sg: Semigroup[T]): T = {
     if(i == 0) {
       vaccMemo._1
     }
@@ -130,31 +130,31 @@ object Semigroup extends GeneratedSemigroupImplicits with ProductSemigroups {
     }
   }
 
-  implicit val nullSemigroup : Semigroup[Null] = NullGroup
-  implicit val unitSemigroup : Semigroup[Unit] = UnitGroup
-  implicit val boolSemigroup : Semigroup[Boolean] = BooleanField
-  implicit val jboolSemigroup : Semigroup[JBool] = JBoolField
-  implicit val intSemigroup : Semigroup[Int] = IntRing
-  implicit val jintSemigroup : Semigroup[JInt] = JIntRing
-  implicit val shortSemigroup : Semigroup[Short] = ShortRing
-  implicit val jshortSemigroup : Semigroup[JShort] = JShortRing
-  implicit val longSemigroup : Semigroup[Long] = LongRing
-  implicit val bigIntSemigroup : Semigroup[BigInt] = BigIntRing
-  implicit val jlongSemigroup : Semigroup[JLong] = JLongRing
-  implicit val floatSemigroup : Semigroup[Float] = FloatField
-  implicit val jfloatSemigroup : Semigroup[JFloat] = JFloatField
-  implicit val doubleSemigroup : Semigroup[Double] = DoubleField
-  implicit val jdoubleSemigroup : Semigroup[JDouble] = JDoubleField
-  implicit val stringSemigroup : Semigroup[String] = StringMonoid
-  implicit def optionSemigroup[T : Semigroup] : Semigroup[Option[T]] = new OptionMonoid[T]
-  implicit def listSemigroup[T] : Semigroup[List[T]] = new ListMonoid[T]
-  implicit def seqSemigroup[T] : Semigroup[Seq[T]] = new SeqMonoid[T]
-  implicit def indexedSeqSemigroup[T : Semigroup]: Semigroup[IndexedSeq[T]] = new IndexedSeqSemigroup[T]
-  implicit def jlistSemigroup[T] : Semigroup[JList[T]] = new JListMonoid[T]
-  implicit def setSemigroup[T] : Semigroup[Set[T]] = new SetMonoid[T]
-  implicit def mapSemigroup[K,V:Semigroup]: Semigroup[Map[K,V]] = new MapMonoid[K,V]
-  implicit def scMapSemigroup[K,V:Semigroup]: Semigroup[ScMap[K,V]] = new ScMapMonoid[K,V]
-  implicit def jmapSemigroup[K,V : Semigroup] : Semigroup[JMap[K, V]] = new JMapMonoid[K,V]
-  implicit def eitherSemigroup[L : Semigroup, R : Semigroup] : Semigroup[Either[L,R]] = new EitherSemigroup[L,R]
-  implicit def function1Semigroup[T] : Semigroup[Function1[T,T]] = new Function1Monoid[T]
+  implicit val nullSemigroup: Semigroup[Null] = NullGroup
+  implicit val unitSemigroup: Semigroup[Unit] = UnitGroup
+  implicit val boolSemigroup: Semigroup[Boolean] = BooleanField
+  implicit val jboolSemigroup: Semigroup[JBool] = JBoolField
+  implicit val intSemigroup: Semigroup[Int] = IntRing
+  implicit val jintSemigroup: Semigroup[JInt] = JIntRing
+  implicit val shortSemigroup: Semigroup[Short] = ShortRing
+  implicit val jshortSemigroup: Semigroup[JShort] = JShortRing
+  implicit val longSemigroup: Semigroup[Long] = LongRing
+  implicit val bigIntSemigroup: Semigroup[BigInt] = BigIntRing
+  implicit val jlongSemigroup: Semigroup[JLong] = JLongRing
+  implicit val floatSemigroup: Semigroup[Float] = FloatField
+  implicit val jfloatSemigroup: Semigroup[JFloat] = JFloatField
+  implicit val doubleSemigroup: Semigroup[Double] = DoubleField
+  implicit val jdoubleSemigroup: Semigroup[JDouble] = JDoubleField
+  implicit val stringSemigroup: Semigroup[String] = StringMonoid
+  implicit def optionSemigroup[T: Semigroup]: Semigroup[Option[T]] = new OptionMonoid[T]
+  implicit def listSemigroup[T]: Semigroup[List[T]] = new ListMonoid[T]
+  implicit def seqSemigroup[T]: Semigroup[Seq[T]] = new SeqMonoid[T]
+  implicit def indexedSeqSemigroup[T: Semigroup]: Semigroup[IndexedSeq[T]] = new IndexedSeqSemigroup[T]
+  implicit def jlistSemigroup[T]: Semigroup[JList[T]] = new JListMonoid[T]
+  implicit def setSemigroup[T]: Semigroup[Set[T]] = new SetMonoid[T]
+  implicit def mapSemigroup[K, V:Semigroup]: Semigroup[Map[K, V]] = new MapMonoid[K, V]
+  implicit def scMapSemigroup[K, V:Semigroup]: Semigroup[ScMap[K, V]] = new ScMapMonoid[K, V]
+  implicit def jmapSemigroup[K, V: Semigroup]: Semigroup[JMap[K, V]] = new JMapMonoid[K, V]
+  implicit def eitherSemigroup[L: Semigroup, R: Semigroup]: Semigroup[Either[L, R]] = new EitherSemigroup[L, R]
+  implicit def function1Semigroup[T]: Semigroup[Function1[T, T]] = new Function1Monoid[T]
 }