Default serializer for sealed types if input has no explicit type

[charleskorn]

What is your use-case and why do you need this feature?

Let's say I have some JSON that looks like this:

{ "type": "typeA", "option": "abc123" }

or

{ "type": "typeB", "otherOption": 15 }

I can use a sealed type to represent these types in Kotlin, and deserialize the JSON into objects without any issues.

However, what I would like to be able to do is default to a particular type if there is no type in the JSON input. For example, if { "option": "abc123" } was the input, I'd like to default to treating that as if it was a typeA.

Describe the solution you'd like
Perhaps this could be done with an annotation on the base class?

For example:

@PolymorphicDefault(TypeA::class)
sealed class Options

data class TypeA(val option: String) : Options
data class TypeB(val otherOption: Int) : Options

[sandwwraith]

We'll have a default function that allows you to register function-handler of unknown polymorphic types in the next release: https://github.com/Kotlin/kotlinx.serialization/blob/dev/runtime/commonMain/src/kotlinx/serialization/modules/PolymorphicModuleBuilder.kt#L42 . It should work with sealed classes as well.

However, it is not designed to work when class discriminator (type field in JSON) is absent completely. Perhaps we can extend it to that, cc @qwwdfsad

[Progdrasil]

I'm not exactly clear on how this is supposed to work, I dont see it in the Polymorphism guide

[sandwwraith]

See https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/polymorphism.md#default-polymorphic-type-handler-for-deserialization : in default { } lambda, className parameter is now String?. null means type property in JSON was absent.

[charleskorn]

Is it possible to use this for a sealed type without creating a serializers module?

For an open type, creating a serializers module is already required, but it seems that in order to use this with a sealed type, you need to create a module (when you would otherwise not need to).

[charleskorn]

It also does not seem possible to use this without special support from the format (eg. this code in the JSON format) because AbstractPolymorphicSerializer.deserialize() assumes the class name is always non-null and calls decodeString(). I would expect it to call decodeNotNullMark() first to check if a class name has been provided.

(I'm trying to add support for this feature to kaml.)

[sandwwraith]

Is it possible to use this for a sealed type without creating a serializers module?

No, module is required. We expect sealed classes to always contain type info, since they're known statically.

It also does not seem possible to use this without special support from the format

Yes, because default polymorphism for arbitrary format is array-based

[FilippoVigani]

No, module is required. We expect sealed classes to always contain type info, since they're known statically.

Sorry for pinging this old issue @sandwwraith , I was wondering if with a sealed class I will need to redefine all the subclasses in a module to support the default value, or just the default { } declaration is sufficient

[sandwwraith]

AFAIR, default is sufficient