Scala 3 enums in a container

[kamilkloch]

Fruit.Orange.type is rendered as "Orange" outside C, as "{}" inside C. Is this the desired behavior?

  enum Fruit {
    case Apple, Orange
  }

  object Fruit {
    given JsonValueCodec[Fruit] = JsonCodecMaker.make(CodecMakerConfig.withDiscriminatorFieldName(None))
  }

  case class C(fruit: Fruit, orange: Fruit.Orange.type)

  given JsonValueCodec[C] = JsonCodecMaker.make

  println(writeToString(Fruit.Orange: Fruit)) // "Orange"
  println(writeToString(Fruit.Orange: Fruit.Orange.type)) // "Orange"
  println(writeToString(C(Fruit.Orange, Fruit.Orange))) // {"fruit":"Orange","orange":{}}

[plokhotnyuk]

Yes, it is expected, because Fruit.Orage.type is not a sum-type itself.

In the 2-nd println of your example given JsonValueCodec[Fruit] is used to serialize Fruit.Orange as a sum-type.

You cannot build a sum-type hierarchy using Scala 3 enums, so the workaround is:

import com.github.plokhotnyuk.jsoniter_scala.core.*
import com.github.plokhotnyuk.jsoniter_scala.macros.*

sealed trait Fruit
object Fruit {
  case object Apple extends Fruit
  
  given JsonValueCodec[Fruit] = JsonCodecMaker.make(CodecMakerConfig.withDiscriminatorFieldName(None))
}

sealed trait Citrus extends Fruit
object Citrus {
  case object Orange extends Citrus
  
  given JsonValueCodec[Citrus] = JsonCodecMaker.make(CodecMakerConfig.withDiscriminatorFieldName(None))
}

case class C(fruit: Fruit, orange: Citrus)

given JsonValueCodec[C] = JsonCodecMaker.make

println(writeToString(Citrus.Orange: Fruit)) // "Orange"
println(writeToString(Citrus.Orange: Citrus)) // "Orange"
println(writeToString(C(Citrus.Orange, Citrus.Orange))) // {"fruit":"Orange","orange":"Orange"}

Or use some sum-type mixed to Orange value:

import com.github.plokhotnyuk.jsoniter_scala.core.*
import com.github.plokhotnyuk.jsoniter_scala.macros.*

sealed trait Citrus

enum Fruit {
  case Apple extends Fruit
  case Orange extends Fruit with Citrus
}

object Fruit {
  given JsonValueCodec[Fruit] = JsonCodecMaker.make(CodecMakerConfig.withDiscriminatorFieldName(None))
}

object Citrus {
  given JsonValueCodec[Citrus] = JsonCodecMaker.make(CodecMakerConfig.withDiscriminatorFieldName(None))
}

case class C(fruit: Fruit, orange: Citrus)

given JsonValueCodec[C] = JsonCodecMaker.make

println(writeToString(Fruit.Orange: Fruit)) // "Orange"
println(writeToString(Fruit.Orange: Citrus)) // "Orange"
println(writeToString(C(Fruit.Orange, Fruit.Orange))) // {"fruit":"Orange","orange":"Orange"}

And the last option is just to write a custom codec exactly for the Fruit.Orange.type:

import com.github.plokhotnyuk.jsoniter_scala.core.*
import com.github.plokhotnyuk.jsoniter_scala.macros.*

enum Fruit {
  case Apple, Orange
}

object Fruit {
  given JsonValueCodec[Fruit] = JsonCodecMaker.make(CodecMakerConfig.withDiscriminatorFieldName(None))
}

given JsonValueCodec[Fruit.Orange.type] = new JsonValueCodec[Fruit.Orange.type] {
  def nullValue: Fruit.Orange.type = null

  def decodeValue(in: JsonReader, default: Fruit.Orange.type): Fruit.Orange.type = {
    val len = in.readStringAsCharBuf()
    if (in.isCharBufEqualsTo(len, "Orange")) Fruit.Orange
    else in.decodeError("""expected "Orange"""")
  }

  def encodeValue(x: Fruit.Orange.type, out: JsonWriter): Unit = out.writeVal("Orange")
}

case class C(fruit: Fruit, orange: Fruit.Orange.type)

given JsonValueCodec[C] = JsonCodecMaker.make

println(writeToString(Fruit.Orange: Fruit)) // "Orange"
println(writeToString(Fruit.Orange: Fruit.Orange.type)) // "Orange"
println(writeToString(C(Fruit.Orange, Fruit.Orange))) // {"fruit":"Orange","orange":"Orange"}

[kamilkloch]

Hello Andriy,

thank you for the response!

In the 2-nd println of your example given JsonValueCodec[Fruit] is used to serialize Fruit.Orange as a sum-type.

Why is that, given the type Fruit.Orange.type? And if this is the case, why given JsonValueCodec[Fruit] is not used for the same type in 3rd println?

You cannot build a sum-type hierarchy using Scala 3 enums, so the workaround is:

Not sure if I understand, scala 3 enums are desugared to a sealed trait under the hood.

Thank you for the proposed solutions. They add some obfuscation code, please take a look at the following approach (relating to #1269) - automatic derivation for leaves, combination of codecs for parent. It would be great if one could use a similar approach in jsoniter.

given config: Configuration = io.circe.derivation.Configuration.default
given orangeEncoder: io.circe.Encoder[Fruit.Orange.type] = Encoder.encodeString.contramap(_.toString)
given appleEncoder: io.circe.Encoder[Fruit.Apple.type] = Encoder.encodeString.contramap(_.toString)
given codec: io.circe.Encoder[Fruit] = Encoder.instance {
   case x: Fruit.Apple.type =>  appleEncoder(x)
   case x: Fruit.Orange.type => orangeEncoder(x)
}

Update: Decoder as chaining leaf black-box decoders:

given orangeDecoder: io.circe.Decoder[Fruit.Orange.type] = Decoder.decodeString.emapTry { x =>
      Try(Fruit.valueOf(x)) match {
        case Success(Fruit.Orange) => Success(Fruit.Orange)
        case _ => Failure(new Exception(""))
      }
    }

given appleDecoder: io.circe.Decoder[Fruit.Apple.type] = Decoder.decodeString.emapTry { x =>
      Try(Fruit.valueOf(x)) match {
        case Success(Fruit.Apple) => Success(Fruit.Apple)
        case _ => Failure(new Exception(""))
      }
    }

given decoder: io.circe.Decoder[Fruit] = orangeDecoder.widen or appleDecoder.widen


println("Orange".asJson.as[Fruit]) // Right(Orange)

[plokhotnyuk]

In the 2-nd println of your example given JsonValueCodec[Fruit] is used to serialize Fruit.Orange as a sum-type.

Why is that, given the type Fruit.Orange.type? And if this is the case, why given JsonValueCodec[Fruit] is not used for the same type in 3rd println?

Widening the type to Fruit for 2-nd println is scalac's work.

Jsoniter-scala's macros don't widen types during derivation and generate codec that serializes Scala object references to {} (a minimal JSON representation) just enough to distinguish it from the null value.