Removed shapeless from Scala 2, since it is fully replaced by Magnolia

build.sbt

@@ -80,7 +80,6 @@ lazy val generic = project
         if (scalaVersion.value.startsWith("2"))
           Seq(
             "com.propensive" %% "magnolia" % magnolia2Version,
-            "com.chuusai" %% "shapeless" % shapelessVersion,
             "org.scala-lang" % "scala-reflect" % scalaVersion.value % Provided
           )
         else

modules/generic/src/main/scala-2/vulcan/generic/package.scala

@@ -6,48 +6,16 @@
 
 package vulcan
 
-import scala.language.experimental.macros
-import scala.reflect.runtime.universe.WeakTypeTag
+import cats.data.Chain
+import cats.free.FreeApplicative
 import cats.implicits._
 import magnolia._
-import shapeless.{:+:, CNil, Coproduct, Inl, Inr, Lazy}
-import shapeless.ops.coproduct.{Inject, Selector}
 import vulcan.internal.tags._
-import cats.data.Chain
-import cats.free.FreeApplicative
 
-package object generic {
-  implicit final val cnilCodec: Codec.Aux[Nothing, CNil] =
-    Codec.UnionCodec(Chain.empty).asInstanceOf[Codec.Aux[Nothing, CNil]].withTypeName("Coproduct")
-
-  implicit final def coproductCodec[H, T <: Coproduct](
-    implicit headCodec: Codec[H],
-    tailCodec: Lazy[Codec[T]]
-  ): Codec[H :+: T] =
-    tailCodec.value match {
-      case Codec.WithTypeName(Codec.Validated(u: Codec.UnionCodec[T], _), typeName) =>
-        val tailAlts: Chain[Codec.Alt[H :+: T]] =
-          u.alts.map(_.imap[H :+: T](_.eliminate(_ => None, Some(_)), Inr(_)))
-        Codec
-          .UnionCodec(
-            tailAlts
-              .prepend(
-                Codec.Alt(headCodec, Prism.instance[H :+: T, H](_.select)(Inl(_)))
-              )
-          )
-          .withTypeName(typeName)
-      case Codec.Fail(error) => Codec.Fail(error)
-      case other =>
-        throw new IllegalArgumentException(
-          s"cannot derive coproduct codec from non-union ${other.getClass()}"
-        )
-    }
+import scala.language.experimental.macros
+import scala.reflect.runtime.universe.WeakTypeTag
 
-  implicit final def coproductPrism[C <: Coproduct, A](
-    implicit inject: Inject[C, A],
-    selector: Selector[C, A]
-  ): Prism[C, A] =
-    Prism.instance(selector(_))(inject(_))
+package object generic {
 
   implicit final class MagnoliaCodec private[generic] (
     private val codec: Codec.type

modules/generic/src/main/scala-3/vulcan/generic/package.scala

@@ -7,19 +7,19 @@
 package vulcan
 
 
-import org.apache.avro.generic._
+import org.apache.avro.generic.*
 import org.apache.avro.Schema
 import shapeless3.deriving._
-import scala.compiletime._
+import scala.compiletime.*
 import scala.reflect.ClassTag
 import scala.deriving.Mirror
 import cats.data.Chain
-import cats.implicits._
+import cats.implicits.*
 import cats.free.FreeApplicative
-import magnolia1._
-import org.apache.avro.generic._
+import magnolia1.*
+import org.apache.avro.generic.*
 import org.apache.avro.Schema
-import vulcan.internal.converters.collection._
+import vulcan.internal.converters.collection.*
 
 package object generic {