Reduce Jar size by using instance constructors

build.sbt

@@ -1,5 +1,4 @@
 import com.typesafe.sbt.SbtGit.GitKeys._
-import sbtcrossproject.CrossPlugin.autoImport.crossProject
 import sbtcrossproject.CrossProject
 
 val Scala212 = "2.12.13"

core/src/main/scala/shapeless/ops/functions.scala

@@ -30,7 +30,13 @@ object function {
   }
 
   object FnToProduct extends FnToProductInstances {
+    type Aux[F, P] = FnToProduct[F] { type Out = P }
     def apply[F <: AnyRef](implicit fntop: FnToProduct[F]): Aux[F, fntop.Out] = fntop
+
+    private[shapeless] def instance[F, P](toProduct: F => P): Aux[F, P] = new FnToProduct[F] {
+      type Out = P
+      def apply(f: F) = toProduct(f)
+    }
   }
 
   /**
@@ -41,6 +47,12 @@ object function {
   trait FnFromProduct[F] extends DepFn1[F] with Serializable
 
   object FnFromProduct extends FnFromProductInstances {
+    type Aux[F, O] = FnFromProduct[F] { type Out = O }
     def apply[F](implicit fnfromp: FnFromProduct[F]): Aux[F, fnfromp.Out] = fnfromp
+
+    private[shapeless] def instance[P, F](fromProduct: P => F): Aux[P, F] = new FnFromProduct[P] {
+      type Out = F
+      def apply(f: P) = fromProduct(f)
+    }
   }
 }

core/src/main/scala/shapeless/ops/hlists.scala

@@ -788,13 +788,16 @@ object hlist {
   trait Tupler[L <: HList] extends DepFn1[L] with Serializable
 
   object Tupler extends TuplerInstances {
+    type Aux[L <: HList, T] = Tupler[L] { type Out = T }
     def apply[L <: HList](implicit tupler: Tupler[L]): Aux[L, tupler.Out] = tupler
 
+    private[shapeless] def instance[L <: HList, T](tuple: L => T): Aux[L, T] = new Tupler[L] {
+      type Out = T
+      def apply(l: L) = tuple(l)
+    }
+
     implicit val hnilTupler: Aux[HNil, Unit] =
-      new Tupler[HNil] {
-        type Out = Unit
-        def apply(l: HNil): Out = ()
-      }
+      instance(_ => ())
   }
 
   /**

core/src/main/scala/shapeless/sized.scala

@@ -221,29 +221,32 @@ object AdditiveCollection {
   import scala.collection.immutable.Queue
   import scala.collection.LinearSeq
 
+  private[this] val instance =
+    new AdditiveCollection[Any] {}
+
   implicit def linearSeqAdditiveCollection[T]: AdditiveCollection[LinearSeq[T]] =
-    new AdditiveCollection[LinearSeq[T]] {}
+    instance.asInstanceOf[AdditiveCollection[LinearSeq[T]]]
 
   implicit def vectorAdditiveCollection[T]: AdditiveCollection[Vector[T]] =
-    new AdditiveCollection[Vector[T]] {}
+    instance.asInstanceOf[AdditiveCollection[Vector[T]]]
 
   implicit def arrayAdditiveCollection[T]: AdditiveCollection[Array[T]] =
-    new AdditiveCollection[Array[T]] {}
+    instance.asInstanceOf[AdditiveCollection[Array[T]]]
 
   implicit def stringAdditiveCollection: AdditiveCollection[String] =
-    new AdditiveCollection[String] {}
+    instance.asInstanceOf[AdditiveCollection[String]]
 
   implicit def listAdditiveCollection[T]: AdditiveCollection[List[T]] =
-    new AdditiveCollection[List[T]] {}
+    instance.asInstanceOf[AdditiveCollection[List[T]]]
 
   implicit def streamAdditiveCollection[T]: AdditiveCollection[LazyList[T]] =
-    new AdditiveCollection[LazyList[T]] {}
+    instance.asInstanceOf[AdditiveCollection[LazyList[T]]]
 
   implicit def queueAdditiveCollection[T]: AdditiveCollection[Queue[T]] =
-    new AdditiveCollection[Queue[T]] {}
+    instance.asInstanceOf[AdditiveCollection[Queue[T]]]
 
   implicit def defaultAdditiveCollection[T]: AdditiveCollection[collection.immutable.IndexedSeq[T]] =
-    new AdditiveCollection[collection.immutable.IndexedSeq[T]] {}
+    instance.asInstanceOf[AdditiveCollection[collection.immutable.IndexedSeq[T]]]
 }
 
 class DefaultToIndexedSeq[CC[_]]