Discriminator does not have effect when deriving sealed trait

There’s a problem with semiautomatic derivations with discriminator when deriving sealed trait.

object Adt {
  sealed trait Result
  case class SimpleResult(res: String) extends Result
  case class ResultWrapper(res: Result)
}

object Codec extends AutoDerivation {
  import io.circe.generic.semiauto._

  implicit val configuration: Configuration = Configuration.default
    .withDiscriminator("type")
    .withSnakeCaseConstructorNames
    .withSnakeCaseMemberNames

  implicit val encWrap: Encoder[Result] = deriveEncoder[Result]
}

object Application extends App {
  import Codec._

  val unwrappedEncoded = {
    val r: Result = SimpleResult("this is result")
    r.asJson.spaces2
  }

  println(s"Unwrapped Encoded: $unwrappedEncoded")
}

results into:

{
  "SimpleResult" : {
    "res" : "this is result"
  }
}

but expected result is:

{
    "res" : "this is result",
    "$type" : "simple_result"
  }

if I wrap result in ResultWrapper, result is correct.

[scalway]

Ok… You have wrong import. This is next fiddle that shows what is changed! https://scalafiddle.io/sf/8XAonaP/4

assume that this issue should be closed!

[ruioliveiras]

After some trouble with the same issue discribed here, i found the sollution. import io.circe.generic.semiauto._ != import io.circe.generic.extras.semiauto._

Example if you want to use: implicit lazy val config: Configuration = Configuration.default .withDiscriminator("type")

You must import impor io.circe.generic.**extras**.semiauto._ (Note the extras before the semi auto 🥲

and use it like this: implicit lazy val codec: Codec[Foo] = deriveConfiguredCodec[Foo]