Scala 3 support?

[pshirshov]

From what I can see, this library isn't published for 3, are there any plans to support it?

[jilen]

Just use circe-core for scala3.
This lib is focusing on improving slow compile time caused by shapeless2 based scala2 circe-generic derivation.

[dispalt]

if you want to cross compile you can do something like this, sorry for the spacing

package io.circe

import io.circe.derivation.Configuration
import io.circe.{ Codec, Decoder, Encoder }

import scala.deriving.Mirror

package object derivation {

  inline final def deriveDecoder[A](using inline A: Mirror.Of[A]): Decoder[A] = Decoder.derived[A]
  inline final def deriveEncoder[A](using inline A: Mirror.Of[A]): Encoder.AsObject[A] = Encoder.AsObject.derived[A]
  inline final def deriveCodec[A](using inline A: Mirror.Of[A]): Codec.AsObject[A] = Codec.AsObject.derived[A]


  inline final def deriveDecoder[A](
                              transformNames: String => String,
                              useDefaults: Boolean,
                              discriminator: Option[String]
                            )(using inline A: Mirror.Of[A]): Decoder[A] = {
    given Configuration(
      transformMemberNames = transformNames,
      useDefaults = useDefaults,
      discriminator = discriminator
    )
    Decoder.derivedConfigured[A]
  }

  inline final def deriveDecoder[A](transformNames: String => String)(using inline A: Mirror.Of[A]): Decoder[A] = {
    given Configuration(
      transformMemberNames = transformNames,
    )
    Decoder.derivedConfigured[A]
  }

  inline final def deriveEncoder[A](
                              transformNames: String => String,
                              discriminator: Option[String]
                            )(using inline A: Mirror.Of[A]): Encoder.AsObject[A] = {
    given Configuration(
      transformMemberNames = transformNames,
      discriminator = discriminator
    )
    Encoder.AsObject.derivedConfigured[A]
  }

  inline final def deriveEncoder[A](transformNames: String => String)(using inline A: Mirror.Of[A]): Encoder.AsObject[A] = {
      given Configuration(
        transformMemberNames = transformNames,
      )
      Encoder.AsObject.derivedConfigured[A]
    }

  inline final def deriveCodec[A](
                            transformNames: String => String,
                            useDefaults: Boolean,
                            discriminator: Option[String]
                          )(using inline A: Mirror.Of[A]): Codec.AsObject[A] = {
    given Configuration(
      transformMemberNames = transformNames,
      useDefaults = useDefaults,
      discriminator = discriminator
    )
    Codec.AsObject.derivedConfigured[A]
  }

  inline final def deriveCodec[A](
                            transformNames: String => String
                          )(using inline A: Mirror.Of[A]): Codec.AsObject[A] = {
    given Configuration(
      transformMemberNames = transformNames,
    )
    Codec.AsObject.derivedConfigured[A]
  }

}