Kotshi can actually help with this

then just create two data classes

one with nullable - would be parsed from API, and then adapter to convert to not nullable

yes i know of that solution 😛 would prefer not having a useless dataclass. this should work

that solution is not so flexible tho

Kotshi

has

@JsonDefaultValueFloat

so that you can specify the default value, so you can save the effort to write your own adapter.

but I believe that it is correct solution

server returns null float -> i want to receive default float, server returns null int -> i want a default int

thats the point of this adapter

then

Kotshi

i know of alternatives. but i would like to understand why this doesnt work

moshi for now has limited abilities to generate adapters

it was just introduced

if i remove the

@JsonQualifier

it works. but i would like to limit this conversion to certain fields only, not app-wide

i am using the reflection adapter, not the code-gen one

ah, ok, then I don’t know

thanks for your help anyway 😛

shouldn't smart cast cover this case ?

fun main(args: Array<String>) {
	listOf("5","12","-10","bar","").map { 
        val foo = it.toIntOrNull()
            when(foo) {
                in 0..10 -> {
                    //foo is not smart cast'ed, it has to be an Int at this point
                    val x = 100 + foo
                    println("shouldn't this be smart casted?")
                }
                else -> {
                    println("$foo : nope")
                } 
            }
    }
}

Problem is that classes can define their own

operator fun contains

, which would be inconsistent.

Maybe it works if you have a

null

branch first, I'm not sure though.

well if i take out the val x = part it will compile and run and foo is always an Int

What? How do you take out the

val foo = ...

part?

the line

the code as is won't compile

Ah sure, if you don't use

foo

the fact that it isn't smartcasted doesn't cause a problem.

because foo in the frist branch is Int? where it could/should be smartcasted

but if the in 0..10 is true then we know for sure that it is an Int

thus it should be smart casted

thats my case here 😃

Problem is there's no way for the compiler to know that

IntRange.contains

only returns true if it's not null.