Update scalafmt to 3.0.1 (twitter#998)

* Update scalafmt to 3.0.1

* fixup! Update scalafmt to 3.0.1

* fixup! Update scalafmt to 3.0.1

Author: regadas

.scalafmt.conf

@@ -1,6 +1,6 @@
-version=2.7.5
+version=3.0.1
 maxColumn = 110
-docstrings = JavaDoc
+docstrings.style = Asterisk
 newlines.alwaysBeforeMultilineDef = false
 newlines.penalizeSingleSelectMultiArgList = false
 align.openParenCallSite = false

algebird-benchmark/src/main/scala/com/twitter/algebird/benchmark/CMSHashingBenchmark.scala

@@ -6,8 +6,8 @@ import com.twitter.algebird.CMSHasher
 /**
  * Benchmarks the hashing algorithms used by Count-Min sketch for CMS[BigInt].
  *
- * The input values are generated ahead of time to ensure that each trial uses the same input (and that the RNG is not
- * influencing the runtime of the trials).
+ * The input values are generated ahead of time to ensure that each trial uses the same input (and that the
+ * RNG is not influencing the runtime of the trials).
  *
  * More details available at https://github.com/twitter/algebird/issues/392.
  */

algebird-bijection/src/main/scala/com/twitter/algebird/bijection/AlgebirdBijections.scala

@@ -22,8 +22,10 @@ import com.twitter.bijection.{AbstractBijection, Bijection, ImplicitBijection, R
 /**
  * Bijections on Algebird's abstract algebra datatypes.
  *
- *  @author Oscar Boykin
- *  @author Sam Ritchie
+ * @author
+ *   Oscar Boykin
+ * @author
+ *   Sam Ritchie
  */
 class BijectedSemigroup[T, U](implicit val sg: Semigroup[T], bij: ImplicitBijection[T, U])
     extends InvariantSemigroup[T, U](bij.bijection.toFunction, bij.bijection.inverse.toFunction) {

algebird-core/src/main/scala-2.13+/com/twitter/algebird/compat.scala

@@ -21,9 +21,11 @@ private[algebird] trait CompatFold {
    * Simple Fold that collects elements into a container.
    */
   def container[I, C[_]](implicit cbf: Factory[I, C[I]]): Fold[I, C[I]] =
-    Fold.foldMutable[Builder[I, C[I]], I, C[I]]({ case (b, i) => b += i }, { _ =>
-      cbf.newBuilder
-    }, { _.result })
+    Fold.foldMutable[Builder[I, C[I]], I, C[I]](
+      { case (b, i) => b += i },
+      _ => cbf.newBuilder,
+      _.result
+    )
 }
 
 private[algebird] trait CompatDecayedVector {

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

@@ -17,16 +17,16 @@ limitations under the License.
 package com.twitter.algebird
 
 /**
- * @author Avi Bryant
+ * @author
+ *   Avi Bryant
  */
 import collection.mutable.HashMap
 import ref.SoftReference
 
 /**
- * This is a summing cache whose goal is to grow until we run out of memory,
- * at which point it clears itself and stops growing.
- * Note that we can lose the values in this cache at any point;
- * we don't put anything here we care about.
+ * This is a summing cache whose goal is to grow until we run out of memory, at which point it clears itself
+ * and stops growing. Note that we can lose the values in this cache at any point; we don't put anything here
+ * we care about.
  */
 class SentinelCache[K, V](implicit sgv: Semigroup[V]) {
   private val map = new SoftReference(new HashMap[K, V]())
@@ -52,13 +52,11 @@ class SentinelCache[K, V](implicit sgv: Semigroup[V]) {
 }
 
 /**
- * This is a wrapper around SummingCache that attempts to grow the capacity
- * by up to some maximum, as long as there's enough RAM.
- * It determines that there's enough RAM to grow by maintaining a SentinelCache
- * which keeps caching and summing the evicted values.
- * Once the SentinelCache has grown to the same size as the current cache,
- * plus some margin, without running out of RAM, then this indicates that we
- * have enough headroom to double the capacity.
+ * This is a wrapper around SummingCache that attempts to grow the capacity by up to some maximum, as long as
+ * there's enough RAM. It determines that there's enough RAM to grow by maintaining a SentinelCache which
+ * keeps caching and summing the evicted values. Once the SentinelCache has grown to the same size as the
+ * current cache, plus some margin, without running out of RAM, then this indicates that we have enough
+ * headroom to double the capacity.
  */
 class AdaptiveCache[K, V: Semigroup](maxCapacity: Int, growthMargin: Double = 3.0)
     extends StatefulSummer[Map[K, V]] {

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

@@ -19,7 +19,8 @@ import algebra.ring.Rng
 
 /**
  * This is for the case where your Ring[T] is a Rng (i.e. there is no unit).
- * @see http://en.wikipedia.org/wiki/Pseudo-ring#Adjoining_an_identity_element
+ * @see
+ *   http://en.wikipedia.org/wiki/Pseudo-ring#Adjoining_an_identity_element
  */
 case class AdjoinedUnit[T](ones: BigInt, get: T) {
   def unwrap: Option[T] = if (ones == 0) Some(get) else None

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

@@ -17,8 +17,7 @@ limitations under the License.
 package com.twitter.algebird
 
 /**
- * Represents functions of the kind:
- * f(x) = slope * x + intercept
+ * Represents functions of the kind: f(x) = slope * x + intercept
  */
 case class AffineFunction[R](slope: R, intercept: R) extends java.io.Serializable {
   def toFn(implicit ring: Ring[R]): Function1[R, R] = { x => this.apply(x)(ring) }
@@ -27,13 +26,11 @@ case class AffineFunction[R](slope: R, intercept: R) extends java.io.Serializabl
 }
 
 /**
- * This feeds the value in on the LEFT!!!  This may seem counter intuitive, but
- * with this approach, a stream/iterator which is summed will have the same output
- * as applying the function one at a time in order to the input.
- * If we did the "lexigraphically correct" thing, which might be (f+g)(x) = f(g(x))
- * then we would wind up reversing the list in the sum.
- * (f1 + f2)(x) = f2(f1(x)) so that:
- * listOfFn.foldLeft(x) { (v, fn) => fn(v) } = (Monoid.sum(listOfFn))(x)
+ * This feeds the value in on the LEFT!!! This may seem counter intuitive, but with this approach, a
+ * stream/iterator which is summed will have the same output as applying the function one at a time in order
+ * to the input. If we did the "lexigraphically correct" thing, which might be (f+g)(x) = f(g(x)) then we
+ * would wind up reversing the list in the sum. (f1 + f2)(x) = f2(f1(x)) so that: listOfFn.foldLeft(x) { (v,
+ * fn) => fn(v) } = (Monoid.sum(listOfFn))(x)
  */
 class AffineFunctionMonoid[R](implicit ring: Ring[R]) extends Monoid[AffineFunction[R]] {
   override lazy val zero: AffineFunction[R] = AffineFunction[R](ring.one, ring.zero)