code improvement (for Scala 3, but good on 2 also)

Author: SethTisue

src/main/scala-2.13+/scala/compat/java8/converterImpl/AccumulatorConverters.scala

@@ -15,18 +15,26 @@ package scala.compat.java8.converterImpl
 import scala.language.implicitConversions
 
 trait Priority3AccumulatorConverters {
-  implicit def collectionCanAccumulate[A](underlying: IterableOnce[A]) = new CollectionCanAccumulate[A](underlying)
+  implicit def collectionCanAccumulate[A](underlying: IterableOnce[A]): CollectionCanAccumulate[A] =
+    new CollectionCanAccumulate[A](underlying)
 }
 
 trait Priority2AccumulatorConverters extends Priority3AccumulatorConverters {
-  implicit def accumulateDoubleCollection(underlying: IterableOnce[Double]) = new AccumulateDoubleCollection(underlying)
-  implicit def accumulateIntCollection(underlying: IterableOnce[Int]) = new AccumulateIntCollection(underlying)
-  implicit def accumulateLongCollection(underlying: IterableOnce[Long]) = new AccumulateLongCollection(underlying)
-  implicit def accumulateAnyArray[A](underlying: Array[A]) = new AccumulateAnyArray(underlying)
+  implicit def accumulateDoubleCollection(underlying: IterableOnce[Double]): AccumulateDoubleCollection =
+    new AccumulateDoubleCollection(underlying)
+  implicit def accumulateIntCollection(underlying: IterableOnce[Int]): AccumulateIntCollection =
+    new AccumulateIntCollection(underlying)
+  implicit def accumulateLongCollection(underlying: IterableOnce[Long]): AccumulateLongCollection =
+    new AccumulateLongCollection(underlying)
+  implicit def accumulateAnyArray[A](underlying: Array[A]): AccumulateAnyArray[A] =
+    new AccumulateAnyArray(underlying)
 }
 
 trait Priority1AccumulatorConverters extends Priority2AccumulatorConverters {
-  implicit def accumulateDoubleArray(underlying: Array[Double]) = new AccumulateDoubleArray(underlying)
-  implicit def accumulateIntArray(underlying: Array[Int]) = new AccumulateIntArray(underlying)
-  implicit def accumulateLongArray(underlying: Array[Long]) = new AccumulateLongArray(underlying)
+  implicit def accumulateDoubleArray(underlying: Array[Double]): AccumulateDoubleArray =
+    new AccumulateDoubleArray(underlying)
+  implicit def accumulateIntArray(underlying: Array[Int]): AccumulateIntArray =
+    new AccumulateIntArray(underlying)
+  implicit def accumulateLongArray(underlying: Array[Long]): AccumulateLongArray =
+    new AccumulateLongArray(underlying)
 }

src/main/scala/scala/compat/java8/OptionConverters.scala

@@ -60,28 +60,31 @@ object OptionConverters {
   }
 
   /** Implementation of creation of `OptionalDouble` from `Option[Double]` or `Optional[Double]`*/
-  implicit val specializer_OptionalDouble = new SpecializerOfOptions[Double, OptionalDouble] {
-    /** Creates an `OptionalDouble` from `Optional[Double]` */
-    def fromJava(o: Optional[Double]): OptionalDouble = if (o.isPresent) OptionalDouble.of(o.get) else OptionalDouble.empty
-    /** Creates an `OptionalDouble` from `Option[Double]` */
-    def fromScala(o: Option[Double]): OptionalDouble = o match { case Some(d) => OptionalDouble.of(d); case _ => OptionalDouble.empty }
-  }
+  implicit val specializer_OptionalDouble: SpecializerOfOptions[Double, OptionalDouble] =
+    new SpecializerOfOptions {
+      /** Creates an `OptionalDouble` from `Optional[Double]` */
+      def fromJava(o: Optional[Double]): OptionalDouble = if (o.isPresent) OptionalDouble.of(o.get) else OptionalDouble.empty
+      /** Creates an `OptionalDouble` from `Option[Double]` */
+      def fromScala(o: Option[Double]): OptionalDouble = o match { case Some(d) => OptionalDouble.of(d); case _ => OptionalDouble.empty }
+    }
 
   /** Implementation of creation of `OptionalInt` from `Option[Int]` or `Optional[Int]`*/
-  implicit val specializer_OptionalInt = new SpecializerOfOptions[Int, OptionalInt] {
-    /** Creates an `OptionalInt` from `Optional[Int]` */
-    def fromJava(o: Optional[Int]): OptionalInt = if (o.isPresent) OptionalInt.of(o.get) else OptionalInt.empty
-    /** Creates an `OptionalInt` from `Option[Int]` */
-    def fromScala(o: Option[Int]): OptionalInt = o match { case Some(d) => OptionalInt.of(d); case _ => OptionalInt.empty }
-  }
+  implicit val specializer_OptionalInt: SpecializerOfOptions[Int, OptionalInt] =
+    new SpecializerOfOptions {
+      /** Creates an `OptionalInt` from `Optional[Int]` */
+      def fromJava(o: Optional[Int]): OptionalInt = if (o.isPresent) OptionalInt.of(o.get) else OptionalInt.empty
+      /** Creates an `OptionalInt` from `Option[Int]` */
+      def fromScala(o: Option[Int]): OptionalInt = o match { case Some(d) => OptionalInt.of(d); case _ => OptionalInt.empty }
+    }
 
   /** Implementation of creation of `OptionalLong` from `Option[Long]` or `Optional[Long]`*/
-  implicit val specializer_OptionalLong = new SpecializerOfOptions[Long, OptionalLong] {
-    /** Creates an `OptionalLong` from `Optional[Long]` */
-    def fromJava(o: Optional[Long]): OptionalLong = if (o.isPresent) OptionalLong.of(o.get) else OptionalLong.empty
-    /** Creates an `OptionalLong` from `Option[Long]` */
-    def fromScala(o: Option[Long]): OptionalLong = o match { case Some(d) => OptionalLong.of(d); case _ => OptionalLong.empty }
-  }
+  implicit val specializer_OptionalLong: SpecializerOfOptions[Long, OptionalLong] =
+    new SpecializerOfOptions {
+      /** Creates an `OptionalLong` from `Optional[Long]` */
+      def fromJava(o: Optional[Long]): OptionalLong = if (o.isPresent) OptionalLong.of(o.get) else OptionalLong.empty
+      /** Creates an `OptionalLong` from `Option[Long]` */
+      def fromScala(o: Option[Long]): OptionalLong = o match { case Some(d) => OptionalLong.of(d); case _ => OptionalLong.empty }
+    }
 
   /** Provides conversions from `java.util.Optional` to Scala `Option` or primitive `java.util.Optional` types */
   implicit class RichOptionalGeneric[A](val underlying: java.util.Optional[A]) extends AnyVal {

src/main/scala/scala/compat/java8/PrimitiveIteratorConversions.scala

@@ -39,76 +39,79 @@ object PrimitiveIteratorConverters {
     /** Packages a Scala `Iterator` to a manually specialized Java variant `That` */
     def fromScala(it: Iterator[A]): That
   }
-  
+
   /** Implementation of wrapping of `java.util.Iterator[Double]` or `scala.collection.Iterator[Double]` as a `java.util.PrimitiveIterator.OfDouble` */
-  implicit val specializer_PrimitiveIteratorDouble = new SpecializerOfIterators[Double, PrimitiveIterator.OfDouble] {
-    /** Packages a `java.util.Iterator[Double]` as a `java.util.PrimitiveIterator.OfDouble` */
-    def fromJava(it: JIterator[Double]): PrimitiveIterator.OfDouble = 
-      new wrappers.IteratorPrimitiveDoubleWrapper(it.asInstanceOf[JIterator[java.lang.Double]])
-    
-    /** Packages a `scala.collection.Iterator[Double]` as a `java.util.PrimitiveIterator.OfDouble` */
-    def fromScala(it: Iterator[Double]): PrimitiveIterator.OfDouble = new PrimitiveIterator.OfDouble {
-      def hasNext = it.hasNext
-      override def next() = it.next().asInstanceOf[java.lang.Double]
-      def nextDouble() = it.next()
-      override def remove(): Unit = { throw new UnsupportedOperationException("remove on scala.collection.Iterator") }
-      override def forEachRemaining(c: java.util.function.Consumer[_ >: java.lang.Double]): Unit = {
-        while (it.hasNext) c.accept(it.next())
-      }
-      override def forEachRemaining(c: java.util.function.DoubleConsumer): Unit = {
-        while (it.hasNext) c.accept(it.next())
+  implicit val specializer_PrimitiveIteratorDouble: SpecializerOfIterators[Double, PrimitiveIterator.OfDouble] =
+    new SpecializerOfIterators {
+      /** Packages a `java.util.Iterator[Double]` as a `java.util.PrimitiveIterator.OfDouble` */
+      def fromJava(it: JIterator[Double]): PrimitiveIterator.OfDouble =
+        new wrappers.IteratorPrimitiveDoubleWrapper(it.asInstanceOf[JIterator[java.lang.Double]])
+
+      /** Packages a `scala.collection.Iterator[Double]` as a `java.util.PrimitiveIterator.OfDouble` */
+      def fromScala(it: Iterator[Double]): PrimitiveIterator.OfDouble = new PrimitiveIterator.OfDouble {
+        def hasNext = it.hasNext
+        override def next() = it.next().asInstanceOf[java.lang.Double]
+        def nextDouble() = it.next()
+        override def remove(): Unit = { throw new UnsupportedOperationException("remove on scala.collection.Iterator") }
+        override def forEachRemaining(c: java.util.function.Consumer[_ >: java.lang.Double]): Unit = {
+          while (it.hasNext) c.accept(it.next())
+        }
+        override def forEachRemaining(c: java.util.function.DoubleConsumer): Unit = {
+          while (it.hasNext) c.accept(it.next())
+        }
       }
     }
-  }
-  
+
   /** Implementation of wrapping of `java.util.Iterator[Int]` or `scala.collection.Iterator[Int]` as a `java.util.PrimitiveIterator.OfInt` */
-  implicit val specializer_PrimitiveIteratorInt = new SpecializerOfIterators[Int, PrimitiveIterator.OfInt] {
-    /** Packages a `java.util.Iterator[Int]` as a `java.util.PrimitiveIterator.OfInt` */
-    def fromJava(it: JIterator[Int]): PrimitiveIterator.OfInt = 
-      new wrappers.IteratorPrimitiveIntWrapper(it.asInstanceOf[JIterator[java.lang.Integer]])
-    
-    /** Packages a `scala.collection.Iterator[Int]` as a `java.util.PrimitiveIterator.OfInt` */
-    def fromScala(it: Iterator[Int]): PrimitiveIterator.OfInt = new PrimitiveIterator.OfInt {
-      def hasNext = it.hasNext
-      override def next() = it.next().asInstanceOf[java.lang.Integer]
-      def nextInt() = it.next()
-      override def remove(): Unit = { throw new UnsupportedOperationException("remove on scala.collection.Iterator") }
-      override def forEachRemaining(c: java.util.function.Consumer[_ >: java.lang.Integer]): Unit = {
-        while (it.hasNext) c.accept(it.next())
-      }
-      override def forEachRemaining(c: java.util.function.IntConsumer): Unit = {
-        while (it.hasNext) c.accept(it.next())
+  implicit val specializer_PrimitiveIteratorInt: SpecializerOfIterators[Int, PrimitiveIterator.OfInt] =
+    new SpecializerOfIterators {
+      /** Packages a `java.util.Iterator[Int]` as a `java.util.PrimitiveIterator.OfInt` */
+      def fromJava(it: JIterator[Int]): PrimitiveIterator.OfInt =
+        new wrappers.IteratorPrimitiveIntWrapper(it.asInstanceOf[JIterator[java.lang.Integer]])
+
+      /** Packages a `scala.collection.Iterator[Int]` as a `java.util.PrimitiveIterator.OfInt` */
+      def fromScala(it: Iterator[Int]): PrimitiveIterator.OfInt = new PrimitiveIterator.OfInt {
+        def hasNext = it.hasNext
+        override def next() = it.next().asInstanceOf[java.lang.Integer]
+        def nextInt() = it.next()
+        override def remove(): Unit = { throw new UnsupportedOperationException("remove on scala.collection.Iterator") }
+        override def forEachRemaining(c: java.util.function.Consumer[_ >: java.lang.Integer]): Unit = {
+          while (it.hasNext) c.accept(it.next())
+        }
+        override def forEachRemaining(c: java.util.function.IntConsumer): Unit = {
+          while (it.hasNext) c.accept(it.next())
+        }
       }
     }
-  }
-  
+
   /** Implementation of wrapping of `java.util.Iterator[Long]` or `scala.collection.Iterator[Long]` as a `java.util.PrimitiveIterator.OfLong` */
-  implicit val specializer_PrimitiveIteratorLong = new SpecializerOfIterators[Long, PrimitiveIterator.OfLong] {
-    /** Packages a `java.util.Iterator[Long]` as a `java.util.PrimitiveIterator.OfLong` */
-    def fromJava(it: JIterator[Long]): PrimitiveIterator.OfLong = 
-      new wrappers.IteratorPrimitiveLongWrapper(it.asInstanceOf[JIterator[java.lang.Long]])
-    
-    /** Packages a `scala.collection.Iterator[Long]` as a `java.util.PrimitiveIterator.OfLong` */
-    def fromScala(it: Iterator[Long]): PrimitiveIterator.OfLong = new PrimitiveIterator.OfLong {
-      def hasNext = it.hasNext
-      override def next() = it.next().asInstanceOf[java.lang.Long]
-      def nextLong() = it.next()
-      override def remove(): Unit = { throw new UnsupportedOperationException("remove on scala.collection.Iterator") }
-      override def forEachRemaining(c: java.util.function.Consumer[_ >: java.lang.Long]): Unit = {
-        while (it.hasNext) c.accept(it.next())
-      }
-      override def forEachRemaining(c: java.util.function.LongConsumer): Unit = {
-        while (it.hasNext) c.accept(it.next())
+  implicit val specializer_PrimitiveIteratorLong: SpecializerOfIterators[Long, PrimitiveIterator.OfLong] =
+    new SpecializerOfIterators {
+      /** Packages a `java.util.Iterator[Long]` as a `java.util.PrimitiveIterator.OfLong` */
+      def fromJava(it: JIterator[Long]): PrimitiveIterator.OfLong =
+        new wrappers.IteratorPrimitiveLongWrapper(it.asInstanceOf[JIterator[java.lang.Long]])
+
+      /** Packages a `scala.collection.Iterator[Long]` as a `java.util.PrimitiveIterator.OfLong` */
+      def fromScala(it: Iterator[Long]): PrimitiveIterator.OfLong = new PrimitiveIterator.OfLong {
+        def hasNext = it.hasNext
+        override def next() = it.next().asInstanceOf[java.lang.Long]
+        def nextLong() = it.next()
+        override def remove(): Unit = { throw new UnsupportedOperationException("remove on scala.collection.Iterator") }
+        override def forEachRemaining(c: java.util.function.Consumer[_ >: java.lang.Long]): Unit = {
+          while (it.hasNext) c.accept(it.next())
+        }
+        override def forEachRemaining(c: java.util.function.LongConsumer): Unit = {
+          while (it.hasNext) c.accept(it.next())
+        }
       }
     }
-  }
-  
+
   /** Provides conversions from Java `Iterator` to manually specialized `PrimitiveIterator` variants, when available */
   implicit final class RichJavaIteratorToPrimitives[A](private val underlying: JIterator[A]) extends AnyVal {
     /** Wraps this `java.util.Iterator` as a manually specialized variant, if possible */
     def asPrimitive[That](implicit specOp: SpecializerOfIterators[A, That]): That = specOp.fromJava(underlying)
   }
-  
+
   /** Provides conversions from Scala `Iterator` to manually specialized `PrimitiveIterator` variants, when available */
   implicit final class RichIteratorToPrimitives[A](private val underlying: Iterator[A]) extends AnyVal {
     /** Wraps this `scala.collection.Iterator` as a manually specialized `java.util.PrimitiveIterator` variant, if possible */